X-Git-Url: https://jxself.org/git/?p=open-adventure.git;a=blobdiff_plain;f=actions.c;h=ceb728a0d86c6ae0f706ce2ca9179c790f4a0f58;hp=29369de08c1ad87498b1b1a64dbca2b3f81ddbab;hb=e060b99baf265d66d7bdb4c4651e16bace183898;hpb=d97574d35c0532d0854b7653b47b2da7e2e305b3 diff --git a/actions.c b/actions.c index 29369de..ceb728a 100644 --- a/actions.c +++ b/actions.c @@ -1,1154 +1,1591 @@ +/* + * Actions for the duneon-running code. + * + * Copyright (c) 1977, 2005 by Will Crowther and Don Woods + * Copyright (c) 2017 by Eric S. Raymond + * SPDX-License-Identifier: BSD-2-clause + */ + #include #include +#include #include "advent.h" -#include "database.h" -#include "newdb.h" - -/* Limit visibility of ugly globals. Eventually these should go away. */ -extern long WD1, WD1X, WD2, WD2X; - -/* - * Action handlers. Eventually we'll do lookup through a method table - * that calls these. - */ +#include "dungeon.h" +#include -static int fill(token_t verb, token_t); +static int fill(verb_t, obj_t); -static int attack(FILE *input, long verb, token_t obj) +static int attack(command_t command) /* Attack. Assume target if unambiguous. "Throw" also links here. * Attackable objects fall into two categories: enemies (snake, * dwarf, etc.) and others (bird, clam, machine). Ambiguous if 2 * enemies, or no enemies but 2 others. */ { - int spk = ACTSPK[verb]; - int d = ATDWRF(game.loc); - if (obj == 0) { - if (d > 0) - obj=DWARF; - if (HERE(SNAKE))obj=obj*NOBJECTS+SNAKE; - if (AT(DRAGON) && game.prop[DRAGON] == 0)obj=obj*NOBJECTS+DRAGON; - if (AT(TROLL))obj=obj*NOBJECTS+TROLL; - if (AT(OGRE))obj=obj*NOBJECTS+OGRE; - if (HERE(BEAR) && game.prop[BEAR] == 0)obj=obj*NOBJECTS+BEAR; - if (obj > NOBJECTS) return GO_UNKNOWN; - if (obj == 0) { - /* Can't attack bird or machine by throwing axe. */ - if (HERE(BIRD) && verb != THROW)obj=BIRD; - if (HERE(VEND) && verb != THROW)obj=obj*NOBJECTS+VEND; - /* Clam and oyster both treated as clam for intransitive case; - * no harm done. */ - if (HERE(CLAM) || HERE(OYSTER))obj=NOBJECTS*obj+CLAM; - if (obj > NOBJECTS) return GO_UNKNOWN; - } + verb_t verb = command.verb; + obj_t obj = command.obj; + + if (obj == INTRANSITIVE) { + int changes = 0; + if (atdwrf(game.loc) > 0) { + obj = DWARF; + ++changes; + } + if (HERE(SNAKE)) { + obj = SNAKE; + ++changes; + } + if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) { + obj = DRAGON; + ++changes; + } + if (AT(TROLL)) { + obj = TROLL; + ++changes; + } + if (AT(OGRE)) { + obj = OGRE; + ++changes; + } + if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) { + obj = BEAR; + ++changes; + } + /* check for low-priority targets */ + if (obj == INTRANSITIVE) { + /* Can't attack bird or machine by throwing axe. */ + if (HERE(BIRD) && verb != THROW) { + obj = BIRD; + ++changes; + } + if (HERE(VEND) && verb != THROW) { + obj = VEND; + ++changes; + } + /* Clam and oyster both treated as clam for intransitive case; + * no harm done. */ + if (HERE(CLAM) || HERE(OYSTER)) { + obj = CLAM; + ++changes; + } + } + if (changes >= 2) + return GO_UNKNOWN; } + if (obj == BIRD) { - spk=UNHAPPY_BIRD; - if (game.closed) - { - RSPEAK(spk); - return GO_CLEAROBJ; - } - DESTROY(BIRD); - game.prop[BIRD]=0; - spk=BIRD_DEAD; + if (game.closed) { + rspeak(UNHAPPY_BIRD); + } else { + DESTROY(BIRD); + rspeak(BIRD_DEAD); + } + return GO_CLEAROBJ; } if (obj == VEND) { - PSPEAK(VEND,game.prop[VEND]+2); - game.prop[VEND]=3-game.prop[VEND]; - return GO_CLEAROBJ; - } - - if (obj == 0)spk=NO_TARGET; - if (obj == CLAM || obj == OYSTER)spk=SHELL_IMPERVIOUS; - if (obj == SNAKE)spk=SNAKE_WARNING; - if (obj == DWARF)spk=BARE_HANDS_QUERY; - if (obj == DWARF && game.closed) return GO_DWARFWAKE; - if (obj == DRAGON)spk=ALREADY_DEAD; - if (obj == TROLL)spk=ROCKY_TROLL; - if (obj == OGRE)spk=OGRE_DODGE; - if (obj == OGRE && d > 0) { - RSPEAK(spk); - RSPEAK(KNIFE_THROWN); - DESTROY(OGRE); - int dwarves=0; - for (int i=1; i < PIRATE; i++) { - if (game.dloc[i] == game.loc) { - ++dwarves; - game.dloc[i] = LOC_LONGWEST; - game.dseen[i]=false; - } - } - spk=spk+1+1/dwarves; /* FIXME: Arithmetic on message numbers */ - } - else if (obj == BEAR) - /* FIXME: Arithmetic on message numbers */ - spk = BEAR_HANDS+(game.prop[BEAR]+1)/2; - else if (obj == DRAGON && game.prop[DRAGON] == 0) { - /* Fun stuff for dragon. If he insists on attacking it, win! - * Set game.prop to dead, move dragon to central loc (still - * fixed), move rug there (not fixed), and move him there, - * too. Then do a null motion to get new description. */ - RSPEAK(BARE_HANDS_QUERY); - GETIN(input,&WD1,&WD1X,&WD2,&WD2X); - if (WD1 != MAKEWD(25) && WD1 != MAKEWD(250519)) - return GO_CHECKFOO; - PSPEAK(DRAGON,3); - game.prop[DRAGON]=1; - game.prop[RUG]=0; - int k=(PLAC[DRAGON]+FIXD[DRAGON])/2; - MOVE(DRAGON+NOBJECTS,-1); - MOVE(RUG+NOBJECTS,0); - MOVE(DRAGON,k); - MOVE(RUG,k); - DROP(BLOOD,k); - for (obj=1; obj<=NOBJECTS; obj++) { - if (game.place[obj] == PLAC[DRAGON] || game.place[obj] == FIXD[DRAGON]) - MOVE(obj,k); - } - game.loc=k; - return GO_MOVE; - } - - RSPEAK(spk); + state_change(VEND, + game.prop[VEND] == VEND_BLOCKS ? VEND_UNBLOCKS : VEND_BLOCKS); + return GO_CLEAROBJ; + } + + if (obj == BEAR) { + switch (game.prop[BEAR]) { + case UNTAMED_BEAR: + rspeak(BEAR_HANDS); + break; + case SITTING_BEAR: + rspeak(BEAR_CONFUSED); + break; + case CONTENTED_BEAR: + rspeak(BEAR_CONFUSED); + break; + case BEAR_DEAD: + rspeak(ALREADY_DEAD); + break; + } + return GO_CLEAROBJ; + } + if (obj == DRAGON && game.prop[DRAGON] == DRAGON_BARS) { + /* Fun stuff for dragon. If he insists on attacking it, win! + * Set game.prop to dead, move dragon to central loc (still + * fixed), move rug there (not fixed), and move him there, + * too. Then do a null motion to get new description. */ + rspeak(BARE_HANDS_QUERY); + if (!silent_yes()) { + speak(arbitrary_messages[NASTY_DRAGON]); + return GO_MOVE; + } + state_change(DRAGON, DRAGON_DEAD); + game.prop[RUG] = RUG_FLOOR; + /* Hardcoding LOC_SECRET5 as the dragon's death location is ugly. + * The way it was computed before was worse; it depended on the + * two dragon locations being LOC_SECRET4 and LOC_SECRET6 and + * LOC_SECRET5 being right between them. + */ + move(DRAGON + NOBJECTS, IS_FIXED); + move(RUG + NOBJECTS, IS_FREE); + move(DRAGON, LOC_SECRET5); + move(RUG, LOC_SECRET5); + drop(BLOOD, LOC_SECRET5); + for (obj_t i = 1; i <= NOBJECTS; i++) { + if (game.place[i] == objects[DRAGON].plac || + game.place[i] == objects[DRAGON].fixd) + move(i, LOC_SECRET5); + } + game.loc = LOC_SECRET5; + return GO_MOVE; + } + + if (obj == OGRE) { + rspeak(OGRE_DODGE); + if (atdwrf(game.loc) == 0) + return GO_CLEAROBJ; + + rspeak(KNIFE_THROWN); + DESTROY(OGRE); + int dwarves = 0; + for (int i = 1; i < PIRATE; i++) { + if (game.dloc[i] == game.loc) { + ++dwarves; + game.dloc[i] = LOC_LONGWEST; + game.dseen[i] = false; + } + } + rspeak((dwarves > 1) ? + OGRE_PANIC1 : + OGRE_PANIC2); + return GO_CLEAROBJ; + } + + switch (obj) { + case INTRANSITIVE: + rspeak(NO_TARGET); + break; + case CLAM: + case OYSTER: + rspeak(SHELL_IMPERVIOUS); + break; + case SNAKE: + rspeak(SNAKE_WARNING); + break; + case DWARF: + if (game.closed) { + return GO_DWARFWAKE; + } + rspeak(BARE_HANDS_QUERY); + break; + case DRAGON: + rspeak(ALREADY_DEAD); + break; + case TROLL: + rspeak(ROCKY_TROLL); + break; + default: + speak(actions[verb].message); + } return GO_CLEAROBJ; } -static int bigwords(long foo) +static int bigwords(vocab_t id) /* FEE FIE FOE FOO (AND FUM). Advance to next state if given in proper order. - * Look up WD1 in section 3 of vocab to determine which word we've got. Last - * word zips the eggs back to the giant room (unless already there). */ + * Look up foo in special section of vocab to determine which word we've got. + * Last word zips the eggs back to the giant room (unless already there). */ { - int k=VOCAB(foo,3); - int spk=NOTHING_HAPPENS; - if (game.foobar != 1-k) { - if (game.foobar != 0)spk=START_OVER; - RSPEAK(spk); - return GO_CLEAROBJ; + if ((game.foobar == WORD_EMPTY && id == FEE) || + (game.foobar == FEE && id == FIE) || + (game.foobar == FIE && id == FOE) || + (game.foobar == FOE && id == FOO) || + (game.foobar == FOE && id == FUM)) { + game.foobar = id; + if ((id != FOO) && (id != FUM)) { + rspeak(OK_MAN); + return GO_CLEAROBJ; + } + game.foobar = WORD_EMPTY; + if (game.place[EGGS] == objects[EGGS].plac || + (TOTING(EGGS) && game.loc == objects[EGGS].plac)) { + rspeak(NOTHING_HAPPENS); + return GO_CLEAROBJ; + } else { + /* Bring back troll if we steal the eggs back from him before + * crossing. */ + if (game.place[EGGS] == LOC_NOWHERE && game.place[TROLL] == LOC_NOWHERE && game.prop[TROLL] == TROLL_UNPAID) + game.prop[TROLL] = TROLL_PAIDONCE; + if (HERE(EGGS)) + pspeak(EGGS, look, EGGS_VANISHED, true); + else if (game.loc == objects[EGGS].plac) + pspeak(EGGS, look, EGGS_HERE, true); + else + pspeak(EGGS, look, EGGS_DONE, true); + move(EGGS, objects[EGGS].plac); + + return GO_CLEAROBJ; + } } else { - game.foobar=k; - if (k != 4) { - RSPEAK(OK_MAN); - return GO_CLEAROBJ; - } - game.foobar=0; - if (game.place[EGGS]==PLAC[EGGS] || (TOTING(EGGS) && game.loc==PLAC[EGGS])) { - RSPEAK(spk); - return GO_CLEAROBJ; - } else { - /* Bring back troll if we steal the eggs back from him before - * crossing. */ - if (game.place[EGGS]==0 && game.place[TROLL]==0 && game.prop[TROLL]==0) - game.prop[TROLL]=1; - k=2; - if (HERE(EGGS))k=1; - if (game.loc == PLAC[EGGS])k=0; - MOVE(EGGS,PLAC[EGGS]); - PSPEAK(EGGS,k); - return GO_CLEAROBJ; - } + if (game.loc == LOC_GIANTROOM) { + rspeak(START_OVER); + } else { + /* This is new begavior in Open Adventure - sounds better when + * player isn't in the Giant Room. */ + rspeak(WELL_POINTLESS); + } + game.foobar = WORD_EMPTY; + return GO_CLEAROBJ; } } -static int bivalve(token_t verb, token_t obj) -/* Clam/oyster actions */ -{ - int spk; - bool is_oyster = (obj == OYSTER); - spk= is_oyster ? OYSTER_OPENS : PEARL_FALLS; - if (TOTING(obj))spk= is_oyster ? DROP_OYSTER : DROP_CLAM; - if (!TOTING(TRIDNT))spk= is_oyster ? OYSTER_OPENER : CLAM_OPENER; - if (verb == LOCK)spk=HUH_MAN; - if (spk == PEARL_FALLS) { - DESTROY(CLAM); - DROP(OYSTER,game.loc); - DROP(PEARL,LOC_CULDESAC); - } - RSPEAK(spk); - return GO_CLEAROBJ; -} - -static int blast(void) +static void blast(void) /* Blast. No effect unless you've got dynamite, which is a neat trick! */ { - if (game.prop[ROD2] < 0 || !game.closed) - { - RSPEAK(REQUIRES_DYNAMITE); - return GO_CLEAROBJ; - } - game.bonus=133; - if (game.loc == LOC_NE) - game.bonus=134; - if (HERE(ROD2)) - game.bonus=135; - RSPEAK(game.bonus); - score(endgame); - return GO_CLEAROBJ; /* pacify compiler - we never get here */ + if (game.prop[ROD2] == STATE_NOTFOUND || + !game.closed) + rspeak(REQUIRES_DYNAMITE); + else { + if (HERE(ROD2)) { + game.bonus = splatter; + rspeak(SPLATTER_MESSAGE); + } else if (game.loc == LOC_NE) { + game.bonus = defeat; + rspeak(DEFEAT_MESSAGE); + } else { + game.bonus = victory; + rspeak(VICTORY_MESSAGE); + } + terminate(endgame); + } } -static int vbreak(token_t verb, token_t obj) +static int vbreak(verb_t verb, obj_t obj) /* Break. Only works for mirror in repository and, of course, the vase. */ { - int spk = ACTSPK[verb]; - if (obj == MIRROR)spk=TOO_FAR; - if (obj == VASE && game.prop[VASE] == 0) { - if (TOTING(VASE))DROP(VASE,game.loc); - game.prop[VASE]=2; - game.fixed[VASE]= -1; - spk=BREAK_VASE; - } else { - if (obj == MIRROR && game.closed) { - RSPEAK(BREAK_MIRROR); - return GO_DWARFWAKE; - } + switch (obj) { + case MIRROR: + if (game.closed) { + state_change(MIRROR, MIRROR_BROKEN); + return GO_DWARFWAKE; + } else { + rspeak(TOO_FAR); + break; + } + case VASE: + if (game.prop[VASE] == VASE_WHOLE) { + if (TOTING(VASE)) + drop(VASE, game.loc); + state_change(VASE, VASE_BROKEN); + game.fixed[VASE] = IS_FIXED; + break; + } + /* FALLTHRU */ + default: + speak(actions[verb].message); } - RSPEAK(spk); - return GO_CLEAROBJ; + return (GO_CLEAROBJ); } static int brief(void) -/* Brief. Intransitive only. Suppress long descriptions after first time. */ +/* Brief. Intransitive only. Suppress full descriptions after first time. */ { - game.abbnum=10000; - game.detail=3; - RSPEAK(BRIEF_CONFIRM); + game.abbnum = 10000; + game.detail = 3; + rspeak(BRIEF_CONFIRM); return GO_CLEAROBJ; } -static int carry(token_t verb, token_t obj) +static int vcarry(verb_t verb, obj_t obj) /* Carry an object. Special cases for bird and cage (if bird in cage, can't * take one without the other). Liquids also special, since they depend on * status of bottle. Also various side effects, etc. */ { - int spk; if (obj == INTRANSITIVE) { - /* Carry, no object given yet. OK if only one object present. */ - if(game.atloc[game.loc] == 0 || - game.link[game.atloc[game.loc]] != 0 || - ATDWRF(game.loc) > 0) - return GO_UNKNOWN; - obj=game.atloc[game.loc]; - } - - if (TOTING(obj)) {RSPEAK(ALREADY_CARRYING); return GO_CLEAROBJ;} - spk=YOU_JOKING; - if (obj == PLANT && game.prop[PLANT] <= 0)spk=DEEP_ROOTS; - if (obj == BEAR && game.prop[BEAR] == 1)spk=BEAR_CHAINED; - if (obj == CHAIN && game.prop[BEAR] != 0)spk=STILL_LOCKED; - if (obj == URN)spk=URN_NOBUDGE; - if (obj == CAVITY)spk=DOUGHNUT_HOLES; - if (obj == BLOOD)spk=FEW_DROPS; - if (obj == RUG && game.prop[RUG] == 2)spk=RUG_HOVERS; - if (obj == SIGN)spk=HAND_PASSTHROUGH; + /* Carry, no object given yet. OK if only one object present. */ + if (game.atloc[game.loc] == NO_OBJECT || + game.link[game.atloc[game.loc]] != 0 || + atdwrf(game.loc) > 0) + return GO_UNKNOWN; + obj = game.atloc[game.loc]; + } + + if (TOTING(obj)) { + speak(actions[verb].message); + return GO_CLEAROBJ; + } + if (obj == MESSAG) { - RSPEAK(REMOVE_MESSAGE); - DESTROY(MESSAG); - return GO_CLEAROBJ; - } - if (game.fixed[obj] != 0) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - if (obj == WATER || obj == OIL) { - if (!HERE(BOTTLE) || LIQUID() != obj) { - if (TOTING(BOTTLE) && game.prop[BOTTLE] == 1) - return(fill(verb, BOTTLE)); - if (game.prop[BOTTLE] != 1)spk=BOTTLE_FULL; - if (!TOTING(BOTTLE))spk=NO_CONTAINER; - RSPEAK(spk); - return GO_CLEAROBJ; - } - obj = BOTTLE; - } - - spk=CARRY_LIMIT; + rspeak(REMOVE_MESSAGE); + DESTROY(MESSAG); + return GO_CLEAROBJ; + } + + if (game.fixed[obj] != IS_FREE) { + switch (obj) { + case PLANT: + /* Next guard tests whether plant is tiny or stashed */ + rspeak(game.prop[PLANT] <= PLANT_THIRSTY ? DEEP_ROOTS : YOU_JOKING); + break; + case BEAR: + rspeak( game.prop[BEAR] == SITTING_BEAR ? BEAR_CHAINED : YOU_JOKING); + break; + case CHAIN: + rspeak( game.prop[BEAR] != UNTAMED_BEAR ? STILL_LOCKED : YOU_JOKING); + break; + case RUG: + rspeak(game.prop[RUG] == RUG_HOVER ? RUG_HOVERS : YOU_JOKING); + break; + case URN: + rspeak(URN_NOBUDGE); + break; + case CAVITY: + rspeak(DOUGHNUT_HOLES); + break; + case BLOOD: + rspeak(FEW_DROPS); + break; + case SIGN: + rspeak(HAND_PASSTHROUGH); + break; + default: + rspeak(YOU_JOKING); + } + return GO_CLEAROBJ; + } + + if (obj == WATER || + obj == OIL) { + if (!HERE(BOTTLE) || + LIQUID() != obj) { + if (!TOTING(BOTTLE)) { + rspeak(NO_CONTAINER); + return GO_CLEAROBJ; + } + if (game.prop[BOTTLE] == EMPTY_BOTTLE) { + return (fill(verb, BOTTLE)); + } else + rspeak(BOTTLE_FULL); + return GO_CLEAROBJ; + } + obj = BOTTLE; + } + if (game.holdng >= INVLIMIT) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - else if (obj == BIRD && game.prop[BIRD] != 1 && -1-game.prop[BIRD] != 1) { - if (game.prop[BIRD] == 2) { - DESTROY(BIRD); - RSPEAK(BIRD_CRAP); - return GO_CLEAROBJ; - } - if (!TOTING(CAGE))spk=CANNOT_CARRY; - if (TOTING(ROD))spk=BIRD_EVADES; - if (spk == CANNOT_CARRY || spk == BIRD_EVADES) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - game.prop[BIRD]=1; - } - if ((obj==BIRD || obj==CAGE) && (game.prop[BIRD]==1 || -1-game.prop[BIRD]==1)) - CARRY(BIRD+CAGE-obj,game.loc); - CARRY(obj,game.loc); - if (obj == BOTTLE && LIQUID() != 0) - game.place[LIQUID()] = CARRIED; - if (GSTONE(obj) && game.prop[obj] != 0) { - game.prop[obj]=0; - game.prop[CAVITY]=1; - } - RSPEAK(OK_MAN); + rspeak(CARRY_LIMIT); + return GO_CLEAROBJ; + + } + + if (obj == BIRD && game.prop[BIRD] != BIRD_CAGED && STASHED(BIRD) != BIRD_CAGED) { + if (game.prop[BIRD] == BIRD_FOREST_UNCAGED) { + DESTROY(BIRD); + rspeak(BIRD_CRAP); + return GO_CLEAROBJ; + } + if (!TOTING(CAGE)) { + rspeak(CANNOT_CARRY); + return GO_CLEAROBJ; + } + if (TOTING(ROD)) { + rspeak(BIRD_EVADES); + return GO_CLEAROBJ; + } + game.prop[BIRD] = BIRD_CAGED; + } + if ((obj == BIRD || + obj == CAGE) && + (game.prop[BIRD] == BIRD_CAGED || STASHED(BIRD) == BIRD_CAGED)) { + /* expression maps BIRD to CAGE and CAGE to BIRD */ + carry(BIRD + CAGE - obj, game.loc); + } + + carry(obj, game.loc); + + if (obj == BOTTLE && LIQUID() != NO_OBJECT) + game.place[LIQUID()] = CARRIED; + + if (GSTONE(obj) && game.prop[obj] != STATE_FOUND) { + game.prop[obj] = STATE_FOUND; + game.prop[CAVITY] = CAVITY_EMPTY; + } + rspeak(OK_MAN); return GO_CLEAROBJ; } -static int chain(token_t verb) +static int chain(verb_t verb) /* Do something to the bear's chain */ { - int spk; if (verb != LOCK) { - spk=CHAIN_UNLOCKED; - if (game.prop[BEAR] == 0)spk=BEAR_BLOCKS; - if (game.prop[CHAIN] == 0)spk=ALREADY_UNLOCKED; - if (spk != CHAIN_UNLOCKED) {RSPEAK(spk); return GO_CLEAROBJ;} - game.prop[CHAIN]=0; - game.fixed[CHAIN]=0; - if (game.prop[BEAR] != 3)game.prop[BEAR]=2; - game.fixed[BEAR]=2-game.prop[BEAR]; - } else { - spk=CHAIN_LOCKED; - if (game.prop[CHAIN] != 0)spk=ALREADY_LOCKED; - if (game.loc != PLAC[CHAIN])spk=NO_LOCKSITE; - if (spk != CHAIN_LOCKED) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - game.prop[CHAIN]=2; - if (TOTING(CHAIN))DROP(CHAIN,game.loc); - game.fixed[CHAIN]= -1; - } - RSPEAK(spk); + if (game.prop[BEAR] == UNTAMED_BEAR) { + rspeak(BEAR_BLOCKS); + return GO_CLEAROBJ; + } + if (game.prop[CHAIN] == CHAIN_HEAP) { + rspeak(ALREADY_UNLOCKED); + return GO_CLEAROBJ; + } + game.prop[CHAIN] = CHAIN_HEAP; + game.fixed[CHAIN] = IS_FREE; + if (game.prop[BEAR] != BEAR_DEAD) + game.prop[BEAR] = CONTENTED_BEAR; + + switch (game.prop[BEAR]) { + // LCOV_EXCL_START + case BEAR_DEAD: + /* Can't be reached until the bear can die in some way other + * than a bridge collapse. Leave in in case this changes, but + * exclude from coverage testing. */ + game.fixed[BEAR] = IS_FIXED; + break; + // LCOV_EXCL_STOP + default: + game.fixed[BEAR] = IS_FREE; + } + rspeak(CHAIN_UNLOCKED); + return GO_CLEAROBJ; + } + + if (game.prop[CHAIN] != CHAIN_HEAP) { + rspeak(ALREADY_LOCKED); + return GO_CLEAROBJ; + } + if (game.loc != objects[CHAIN].plac) { + rspeak(NO_LOCKSITE); + return GO_CLEAROBJ; + } + + game.prop[CHAIN] = CHAIN_FIXED; + + if (TOTING(CHAIN)) + drop(CHAIN, game.loc); + game.fixed[CHAIN] = IS_FIXED; + + rspeak(CHAIN_LOCKED); return GO_CLEAROBJ; } -static int discard(token_t verb, token_t obj, bool just_do_it) +static int discard(verb_t verb, obj_t obj) /* Discard object. "Throw" also comes here for most objects. Special cases for * bird (might attack snake or dragon) and cage (might contain bird) and vase. * Drop coins at vending machine for extra batteries. */ { - int spk = ACTSPK[verb]; - if (!just_do_it) { - if (TOTING(ROD2) && obj == ROD && !TOTING(ROD))obj=ROD2; - if (!TOTING(obj)) {RSPEAK(spk); return GO_CLEAROBJ;} - if (obj == BIRD && HERE(SNAKE)) { - RSPEAK(BIRD_ATTACKS); - if (game.closed) return GO_DWARFWAKE; - DESTROY(SNAKE); - /* Set game.prop for use by travel options */ - game.prop[SNAKE]=1; - - } else if ((GSTONE(obj) && AT(CAVITY) && game.prop[CAVITY] != 0)) { - RSPEAK(GEM_FITS); - game.prop[obj]=1; - game.prop[CAVITY]=0; - if (HERE(RUG) && ((obj == EMRALD && game.prop[RUG] != 2) || (obj == RUBY && - game.prop[RUG] == 2))) { - spk=RUG_RISES; - if (TOTING(RUG))spk=RUG_WIGGLES; - if (obj == RUBY)spk=RUG_SETTLES; - RSPEAK(spk); - if (spk != RUG_WIGGLES) { - int k = 2-game.prop[RUG]; - game.prop[RUG] = k; - if (k == 2) k = PLAC[SAPPH]; - MOVE(RUG+NOBJECTS, k); - } + if (obj == ROD && !TOTING(ROD) && TOTING(ROD2)) { + obj = ROD2; + } + + if (!TOTING(obj)) { + speak(actions[verb].message); + return GO_CLEAROBJ; + } + + if (GSTONE(obj) && AT(CAVITY) && game.prop[CAVITY] != CAVITY_FULL) { + rspeak(GEM_FITS); + game.prop[obj] = STATE_IN_CAVITY; + game.prop[CAVITY] = CAVITY_FULL; + if (HERE(RUG) && ((obj == EMERALD && game.prop[RUG] != RUG_HOVER) || + (obj == RUBY && game.prop[RUG] == RUG_HOVER))) { + if (obj == RUBY) + rspeak(RUG_SETTLES); + else if (TOTING(RUG)) + rspeak(RUG_WIGGLES); + else + rspeak(RUG_RISES); + if (!TOTING(RUG) || obj == RUBY) { + int k = (game.prop[RUG] == RUG_HOVER) ? RUG_FLOOR : RUG_HOVER; + game.prop[RUG] = k; + if (k == RUG_HOVER) + k = objects[SAPPH].plac; + move(RUG + NOBJECTS, k); } - } else if (obj == COINS && HERE(VEND)) { - DESTROY(COINS); - DROP(BATTER,game.loc); - PSPEAK(BATTER,0); + } + drop(obj, game.loc); + return GO_CLEAROBJ; + } + + if (obj == COINS && HERE(VEND)) { + DESTROY(COINS); + drop(BATTERY, game.loc); + pspeak(BATTERY, look, FRESH_BATTERIES, true); + return GO_CLEAROBJ; + } + + if (LIQUID() == obj) + obj = BOTTLE; + if (obj == BOTTLE && LIQUID() != NO_OBJECT) { + game.place[LIQUID()] = LOC_NOWHERE; + } + + if (obj == BEAR && AT(TROLL)) { + state_change(TROLL, TROLL_GONE); + move(TROLL, LOC_NOWHERE); + move(TROLL + NOBJECTS, IS_FREE); + move(TROLL2, objects[TROLL].plac); + move(TROLL2 + NOBJECTS, objects[TROLL].fixd); + juggle(CHASM); + drop(obj, game.loc); + return GO_CLEAROBJ; + } + + if (obj == VASE) { + if (game.loc != objects[PILLOW].plac) { + state_change(VASE, AT(PILLOW) + ? VASE_WHOLE + : VASE_DROPPED); + if (game.prop[VASE] != VASE_WHOLE) + game.fixed[VASE] = IS_FIXED; + drop(obj, game.loc); return GO_CLEAROBJ; - } else if (obj == BIRD && AT(DRAGON) && game.prop[DRAGON] == 0) { - RSPEAK(BIRD_BURNT); + } + } + + if (obj == CAGE && game.prop[BIRD] == BIRD_CAGED) { + drop(BIRD, game.loc); + } + + if (obj == BIRD) { + if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) { + rspeak(BIRD_BURNT); DESTROY(BIRD); - game.prop[BIRD]=0; return GO_CLEAROBJ; - } else if (obj == BEAR && AT(TROLL)) { - RSPEAK(TROLL_SCAMPERS); - MOVE(TROLL,0); - MOVE(TROLL+NOBJECTS,0); - MOVE(TROLL2,PLAC[TROLL]); - MOVE(TROLL2+NOBJECTS,FIXD[TROLL]); - JUGGLE(CHASM); - game.prop[TROLL]=2; - } else if (obj != VASE || game.loc == PLAC[PILLOW]) { - RSPEAK(OK_MAN); - } else { - game.prop[VASE]=2; - if (AT(PILLOW))game.prop[VASE]=0; - PSPEAK(VASE,game.prop[VASE]+1); - if (game.prop[VASE] != 0)game.fixed[VASE]= -1; - } - } - int k = LIQUID(); - if (k == obj)obj=BOTTLE; - if (obj == BOTTLE && k != 0) - game.place[k] = NOWHERE; - if (obj == CAGE && game.prop[BIRD] == 1)DROP(BIRD,game.loc); - DROP(obj,game.loc); - if (obj != BIRD) return GO_CLEAROBJ; - game.prop[BIRD]=0; - if (FOREST(game.loc))game.prop[BIRD]=2; + } + if (HERE(SNAKE)) { + rspeak(BIRD_ATTACKS); + if (game.closed) + return GO_DWARFWAKE; + DESTROY(SNAKE); + /* Set game.prop for use by travel options */ + game.prop[SNAKE] = SNAKE_CHASED; + } else + rspeak(OK_MAN); + + game.prop[BIRD] = FOREST(game.loc) ? BIRD_FOREST_UNCAGED : BIRD_UNCAGED; + drop(obj, game.loc); + return GO_CLEAROBJ; + } + + rspeak(OK_MAN); + drop(obj, game.loc); return GO_CLEAROBJ; } -static int drink(token_t verb, token_t obj) +static int drink(verb_t verb, obj_t obj) /* Drink. If no object, assume water and look for it here. If water is in * the bottle, drink that, else must be at a water loc, so drink stream. */ { - int spk = ACTSPK[verb]; - if (obj == 0 && LIQLOC(game.loc) != WATER && (LIQUID() != WATER || !HERE(BOTTLE))) - return GO_UNKNOWN; - if (obj != BLOOD) { - if (obj != 0 && obj != WATER)spk=RIDICULOUS_ATTEMPT; - if (spk != RIDICULOUS_ATTEMPT && LIQUID() == WATER && HERE(BOTTLE)) { - game.prop[BOTTLE] = 1; - game.place[WATER] = NOWHERE; - spk=BOTTLE_EMPTY; - } - } else { - DESTROY(BLOOD); - game.prop[DRAGON]=2; - OBJSND[BIRD]=OBJSND[BIRD]+3; - spk=HEAD_BUZZES; + if (obj == INTRANSITIVE && LIQLOC(game.loc) != WATER && + (LIQUID() != WATER || !HERE(BOTTLE))) { + return GO_UNKNOWN; + } + + if (obj == BLOOD) { + DESTROY(BLOOD); + state_change(DRAGON, DRAGON_BLOODLESS); + game.blooded = true; + return GO_CLEAROBJ; + } + + if (obj != INTRANSITIVE && obj != WATER) { + rspeak(RIDICULOUS_ATTEMPT); + return GO_CLEAROBJ; } - RSPEAK(spk); + if (LIQUID() == WATER && HERE(BOTTLE)) { + game.place[WATER] = LOC_NOWHERE; + state_change(BOTTLE, EMPTY_BOTTLE); + return GO_CLEAROBJ; + } + + speak(actions[verb].message); return GO_CLEAROBJ; } -static int eat(token_t verb, token_t obj) +static int eat(verb_t verb, obj_t obj) /* Eat. Intransitive: assume food if present, else ask what. Transitive: food * ok, some things lose appetite, rest are ridiculous. */ { - int spk = ACTSPK[verb]; - if (obj == INTRANSITIVE) { - if (!HERE(FOOD)) - return GO_UNKNOWN; - DESTROY(FOOD); - spk=THANKS_DELICIOUS; - } else { - if (obj == FOOD) { - DESTROY(FOOD); - spk=THANKS_DELICIOUS; - } - if (obj == BIRD || obj == SNAKE || obj == CLAM || obj == OYSTER || obj == - DWARF || obj == DRAGON || obj == TROLL || obj == BEAR || obj == - OGRE)spk=LOST_APPETITE; - } - RSPEAK(spk); + switch (obj) { + case INTRANSITIVE: + if (!HERE(FOOD)) + return GO_UNKNOWN; + /* FALLTHRU */ + case FOOD: + DESTROY(FOOD); + rspeak(THANKS_DELICIOUS); + break; + case BIRD: + case SNAKE: + case CLAM: + case OYSTER: + case DWARF: + case DRAGON: + case TROLL: + case BEAR: + case OGRE: + rspeak(LOST_APPETITE); + break; + default: + speak(actions[verb].message); + } return GO_CLEAROBJ; } -static int extinguish(token_t verb, int obj) +static int extinguish(verb_t verb, obj_t obj) /* Extinguish. Lamp, urn, dragon/volcano (nice try). */ { - int spk = ACTSPK[verb]; if (obj == INTRANSITIVE) { - if (HERE(LAMP) && game.prop[LAMP] == 1)obj=LAMP; - if (HERE(URN) && game.prop[URN] == 2)obj=obj*NOBJECTS+URN; - if (obj == INTRANSITIVE || obj == 0 || obj > NOBJECTS) return GO_UNKNOWN; + if (HERE(LAMP) && game.prop[LAMP] == LAMP_BRIGHT) + obj = LAMP; + if (HERE(URN) && game.prop[URN] == URN_LIT) + obj = URN; + if (obj == INTRANSITIVE) + return GO_UNKNOWN; } - if (obj == URN) { - game.prop[URN]=game.prop[URN]/2; - spk=URN_DARK; - } - else if (obj == LAMP) { - game.prop[LAMP]=0; - RSPEAK(LAMP_OFF); - spk = DARK(game.loc) ? PITCH_DARK : ARB_0; + switch (obj) { + case URN: + if (game.prop[URN] != URN_EMPTY) { + state_change(URN, URN_DARK); + } else { + pspeak(URN, change, URN_DARK, true); + } + break; + case LAMP: + state_change(LAMP, LAMP_DARK); + rspeak(DARK(game.loc) ? + PITCH_DARK : + NO_MESSAGE); + break; + case DRAGON: + case VOLCANO: + rspeak(BEYOND_POWER); + break; + default: + speak(actions[verb].message); } - else if (obj == DRAGON || obj == VOLCAN) - spk=BEYOND_POWER; - RSPEAK(spk); return GO_CLEAROBJ; } -static int feed(token_t verb, token_t obj) +static int feed(verb_t verb, obj_t obj) /* Feed. If bird, no seed. Snake, dragon, troll: quip. If dwarf, make him * mad. Bear, special. */ { - int spk = ACTSPK[verb]; - if (obj == BIRD) { - RSPEAK(BIRD_PINING); - return GO_CLEAROBJ; - } - else if (obj == SNAKE || obj == DRAGON || obj == TROLL) { - spk=NOTHING_EDIBLE; - if (obj == DRAGON && game.prop[DRAGON] != 0)spk=RIDICULOUS_ATTEMPT; - if (obj == TROLL)spk=TROLL_VICES; - if (obj == SNAKE && !game.closed && HERE(BIRD)) { - DESTROY(BIRD); - game.prop[BIRD]=0; - spk = BIRD_DEVOURED; - } - } - else if (obj == DWARF) { - if (HERE(FOOD)) { - game.dflag += 2; - spk = REALLY_MAD; - } - } - else if (obj == BEAR) { - if (game.prop[BEAR] == 0)spk=NOTHING_EDIBLE; - if (game.prop[BEAR] == 3)spk=RIDICULOUS_ATTEMPT; - if (HERE(FOOD)) { - DESTROY(FOOD); - game.prop[BEAR]=1; - game.fixed[AXE]=0; - game.prop[AXE]=0; - spk=BEAR_TAMED; - } - } - else if (obj == OGRE) { - if (HERE(FOOD)) - spk=OGRE_FULL; - } else { - spk=AM_GAME; + switch (obj) { + case BIRD: + rspeak(BIRD_PINING); + break; + case DRAGON: + if (game.prop[DRAGON] != DRAGON_BARS) + rspeak(RIDICULOUS_ATTEMPT); + else + rspeak(NOTHING_EDIBLE); + break; + case SNAKE: + if (!game.closed && HERE(BIRD)) { + DESTROY(BIRD); + rspeak(BIRD_DEVOURED); + } else + rspeak(NOTHING_EDIBLE); + break; + case TROLL: + rspeak(TROLL_VICES); + break; + case DWARF: + if (HERE(FOOD)) { + game.dflag += 2; + rspeak(REALLY_MAD); + } else + speak(actions[verb].message); + break; + case BEAR: + if (game.prop[BEAR] == BEAR_DEAD) { + rspeak(RIDICULOUS_ATTEMPT); + break; + } + if (game.prop[BEAR] == UNTAMED_BEAR) { + if (HERE(FOOD)) { + DESTROY(FOOD); + game.fixed[AXE] = IS_FREE; + game.prop[AXE] = AXE_HERE; + state_change(BEAR, SITTING_BEAR); + } else + rspeak(NOTHING_EDIBLE); + break; + } + speak(actions[verb].message); + break; + case OGRE: + if (HERE(FOOD)) + rspeak(OGRE_FULL); + else + speak(actions[verb].message); + break; + default: + rspeak(AM_GAME); } - RSPEAK(spk); return GO_CLEAROBJ; } -int fill(token_t verb, token_t obj) +int fill(verb_t verb, obj_t obj) /* Fill. Bottle or urn must be empty, and liquid available. (Vase * is nasty.) */ { - int k; - int spk = ACTSPK[verb]; if (obj == VASE) { - spk=ARENT_CARRYING; - if (LIQLOC(game.loc) == 0)spk=FILL_INVALID; - if (LIQLOC(game.loc) == 0 || !TOTING(VASE)) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - RSPEAK(SHATTER_VASE); - game.prop[VASE] = 2; - game.fixed[VASE]= -1; - return(discard(verb, obj, true)); - } - else if (obj == URN) { - spk=FULL_URN; - if (game.prop[URN] != 0) {RSPEAK(spk); return GO_CLEAROBJ;} - spk=FILL_INVALID; - k=LIQUID(); - if (k == 0 || !HERE(BOTTLE)) {RSPEAK(spk); return GO_CLEAROBJ;} - game.place[k] = NOWHERE; - game.prop[BOTTLE] = 1; - if (k == OIL)game.prop[URN]=1; - spk=WATER_URN+game.prop[URN]; - RSPEAK(spk); - return GO_CLEAROBJ; - } - else if (obj != 0 && obj != BOTTLE) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - else if (obj == 0 && !HERE(BOTTLE)) - return GO_UNKNOWN; - spk=BOTTLED_WATER; - if (LIQLOC(game.loc) == 0) - spk=NO_LIQUID; - if (HERE(URN) && game.prop[URN] != 0) - spk=URN_NOPOUR; - if (LIQUID() != 0) - spk=BOTTLE_FULL; - if (spk == 107) { - game.prop[BOTTLE]=MOD(COND[game.loc],4)/2*2; - k=LIQUID(); - if (TOTING(BOTTLE)) - game.place[k] = CARRIED; - if (k == OIL) - spk=BOTTLED_OIL; - } - RSPEAK(spk); + if (LIQLOC(game.loc) == NO_OBJECT) { + rspeak(FILL_INVALID); + return GO_CLEAROBJ; + } + if (!TOTING(VASE)) { + rspeak(ARENT_CARRYING); + return GO_CLEAROBJ; + } + rspeak(SHATTER_VASE); + game.prop[VASE] = VASE_BROKEN; + game.fixed[VASE] = IS_FIXED; + drop(VASE, game.loc); + return GO_CLEAROBJ; + } + + if (obj == URN) { + if (game.prop[URN] != URN_EMPTY) { + rspeak(FULL_URN); + return GO_CLEAROBJ; + } + if (!HERE(BOTTLE)) { + rspeak(FILL_INVALID); + return GO_CLEAROBJ; + } + int k = LIQUID(); + switch (k) { + case WATER: + game.prop[BOTTLE] = EMPTY_BOTTLE; + rspeak(WATER_URN); + break; + case OIL: + game.prop[URN] = URN_DARK; + game.prop[BOTTLE] = EMPTY_BOTTLE; + rspeak(OIL_URN); + break; + case NO_OBJECT: + default: + rspeak(FILL_INVALID); + return GO_CLEAROBJ; + } + game.place[k] = LOC_NOWHERE; + return GO_CLEAROBJ; + } + if (obj != INTRANSITIVE && obj != BOTTLE) { + speak(actions[verb].message); + return GO_CLEAROBJ; + } + if (obj == INTRANSITIVE && !HERE(BOTTLE)) + return GO_UNKNOWN; + + if (HERE(URN) && game.prop[URN] != URN_EMPTY) { + rspeak(URN_NOPOUR); + return GO_CLEAROBJ; + } + if (LIQUID() != NO_OBJECT) { + rspeak(BOTTLE_FULL); + return GO_CLEAROBJ; + } + if (LIQLOC(game.loc) == NO_OBJECT) { + rspeak(NO_LIQUID); + return GO_CLEAROBJ; + } + + state_change(BOTTLE, (LIQLOC(game.loc) == OIL) + ? OIL_BOTTLE + : WATER_BOTTLE); + if (TOTING(BOTTLE)) + game.place[LIQUID()] = CARRIED; return GO_CLEAROBJ; } -static int find(token_t verb, token_t obj) +static int find(verb_t verb, obj_t obj) /* Find. Might be carrying it, or it might be here. Else give caveat. */ { - int spk = ACTSPK[verb]; + if (TOTING(obj)) { + rspeak(ALREADY_CARRYING); + return GO_CLEAROBJ; + } + + if (game.closed) { + rspeak(NEEDED_NEARBY); + return GO_CLEAROBJ; + } + if (AT(obj) || - (LIQUID() == obj && AT(BOTTLE)) || - obj == LIQLOC(game.loc) || - (obj == DWARF && ATDWRF(game.loc) > 0)) - spk=YOU_HAVEIT; - if (game.closed)spk=NEEDED_NEreplace; - if (TOTING(obj))spk=ALREADY_CARRYING; - RSPEAK(spk); + (LIQUID() == obj && AT(BOTTLE)) || + obj == LIQLOC(game.loc) || + (obj == DWARF && atdwrf(game.loc) > 0)) { + rspeak(YOU_HAVEIT); + return GO_CLEAROBJ; + } + + + speak(actions[verb].message); return GO_CLEAROBJ; } -static int fly(token_t verb, token_t obj) +static int fly(verb_t verb, obj_t obj) /* Fly. Snide remarks unless hovering rug is here. */ { - int spk = ACTSPK[verb]; if (obj == INTRANSITIVE) { - if (game.prop[RUG] != 2)spk=RUG_NOTHING2; - if (!HERE(RUG))spk=FLAP_ARMS; - if (spk == RUG_NOTHING2 || spk == FLAP_ARMS) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - obj=RUG; + if (!HERE(RUG)) { + rspeak(FLAP_ARMS); + return GO_CLEAROBJ; + } + if (game.prop[RUG] != RUG_HOVER) { + rspeak(RUG_NOTHING2); + return GO_CLEAROBJ; + } + obj = RUG; } if (obj != RUG) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - spk=RUG_NOTHING1; - if (game.prop[RUG] != 2) {RSPEAK(spk); return GO_CLEAROBJ;} - game.oldlc2=game.oldloc; - game.oldloc=game.loc; - game.newloc=game.place[RUG]+game.fixed[RUG]-game.loc; - spk=RUG_GOES; - if (game.prop[SAPPH] >= 0) - spk=RUG_RETURNS; - RSPEAK(spk); + speak(actions[verb].message); + return GO_CLEAROBJ; + } + if (game.prop[RUG] != RUG_HOVER) { + rspeak(RUG_NOTHING1); + return GO_CLEAROBJ; + } + game.oldlc2 = game.oldloc; + game.oldloc = game.loc; + + if (game.prop[SAPPH] == STATE_NOTFOUND) { + game.newloc = game.place[SAPPH]; + rspeak(RUG_GOES); + } else { + game.newloc = LOC_CLIFF; + rspeak(RUG_RETURNS); + } return GO_TERMINATE; } static int inven(void) /* Inventory. If object, treat same as find. Else report on current burden. */ { - int spk=NO_CARRY; - for (int i=1; i<=NOBJECTS; i++) { - if (i == BEAR || !TOTING(i)) - continue; - if (spk == NO_CARRY) - RSPEAK(NOW_HOLDING); - game.blklin=false; - PSPEAK(i,-1); - game.blklin=true; - spk=ARB_0; + bool empty = true; + for (obj_t i = 1; i <= NOBJECTS; i++) { + if (i == BEAR || + !TOTING(i)) + continue; + if (empty) { + rspeak(NOW_HOLDING); + empty = false; + } + pspeak(i, touch, -1, false); } if (TOTING(BEAR)) - spk=TAME_BEAR; - RSPEAK(spk); + rspeak(TAME_BEAR); + if (empty) + rspeak(NO_CARRY); return GO_CLEAROBJ; } -int light(token_t verb, token_t obj) +static int light(verb_t verb, obj_t obj) /* Light. Applicable only to lamp and urn. */ { - int spk = ACTSPK[verb]; if (obj == INTRANSITIVE) { - if (HERE(LAMP) && game.prop[LAMP] == 0 && game.limit >= 0)obj=LAMP; - if (HERE(URN) && game.prop[URN] == 1)obj=obj*NOBJECTS+URN; - if (obj == INTRANSITIVE || obj == 0 || obj > NOBJECTS) return GO_UNKNOWN; + int selects = 0; + if (HERE(LAMP) && game.prop[LAMP] == LAMP_DARK && game.limit >= 0) { + obj = LAMP; + selects++; + } + if (HERE(URN) && game.prop[URN] == URN_DARK) { + obj = URN; + selects++; + } + if (selects != 1) + return GO_UNKNOWN; } - if (obj == URN) { - spk=URN_EMPTY; - if (game.prop[URN] == 0) - {RSPEAK(spk); return GO_CLEAROBJ;} - spk=URN_LIT; - game.prop[URN]=2; - RSPEAK(spk); - return GO_CLEAROBJ; - } else { - if (obj != LAMP) - { - RSPEAK(spk); - return GO_CLEAROBJ; - } - spk=LAMP_OUT; - if (game.limit < 0) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - game.prop[LAMP]=1; - RSPEAK(LAMP_ON); - if (game.wzdark) - return GO_TOP; - else - return GO_CLEAROBJ; + switch (obj) { + case URN: + state_change(URN, game.prop[URN] == URN_EMPTY ? + URN_EMPTY : + URN_LIT); + break; + case LAMP: + if (game.limit < 0) { + rspeak(LAMP_OUT); + break; + } + state_change(LAMP, LAMP_BRIGHT); + if (game.wzdark) + return GO_TOP; + break; + default: + speak(actions[verb].message); } + return GO_CLEAROBJ; } static int listen(void) -/* Listen. Intransitive only. Print stuff based on objsnd/locsnd. */ +/* Listen. Intransitive only. Print stuff based on object sound proprties. */ { - int k; - int spk=ALL_SILENT; - k=LOCSND[game.loc]; - if (k != 0) { - RSPEAK(labs(k)); - if (k < 0) return GO_CLEAROBJ; - spk=ARB_0; - } - SETPRM(1,game.zzword,0); - for (int i=1; i<=NOBJECTS; i++) { - if (!HERE(i) || OBJSND[i] == 0 || game.prop[i] < 0) - continue; - PSPEAK(i,OBJSND[i]+game.prop[i]); - spk=ARB_0; - if (i == BIRD && OBJSND[i]+game.prop[i] == 8) - DESTROY(BIRD); - } - RSPEAK(spk); + vocab_t sound = locations[game.loc].sound; + if (sound != SILENT) { + rspeak(sound); + if (!locations[game.loc].loud) + rspeak(NO_MESSAGE); + return GO_CLEAROBJ; + } + for (obj_t i = 1; i <= NOBJECTS; i++) { + if (!HERE(i) || + objects[i].sounds[0] == NULL || + game.prop[i] < 0) + continue; + int mi = game.prop[i]; + /* (ESR) Some unpleasant magic on object states here. Ideally + * we'd have liked the bird to be a normal object that we can + * use state_change() on; can't do it, because there are + * actually two different series of per-state birdsounds + * depending on whether player has drunk dragon's blood. */ + if (i == BIRD) + mi += 3 * game.blooded; + pspeak(i, hear, mi, true, game.zzword); + rspeak(NO_MESSAGE); + if (i == BIRD && mi == BIRD_ENDSTATE) + DESTROY(BIRD); + return GO_CLEAROBJ; + } + rspeak(ALL_SILENT); return GO_CLEAROBJ; } -static int lock(token_t verb, token_t obj) +static int lock(verb_t verb, obj_t obj) /* Lock, unlock, no object given. Assume various things if present. */ { - int spk = ACTSPK[verb]; if (obj == INTRANSITIVE) { - spk=NOTHING_LOCKED; - if (HERE(CLAM))obj=CLAM; - if (HERE(OYSTER))obj=OYSTER; - if (AT(DOOR))obj=DOOR; - if (AT(GRATE))obj=GRATE; - if (obj != 0 && HERE(CHAIN)) return GO_UNKNOWN; - if (HERE(CHAIN))obj=CHAIN; - if (obj == 0) {RSPEAK(spk); return GO_CLEAROBJ;} - } - + if (HERE(CLAM)) + obj = CLAM; + if (HERE(OYSTER)) + obj = OYSTER; + if (AT(DOOR)) + obj = DOOR; + if (AT(GRATE)) + obj = GRATE; + if (HERE(CHAIN)) + obj = CHAIN; + if (obj == INTRANSITIVE) { + rspeak(NOTHING_LOCKED); + return GO_CLEAROBJ; + } + } + /* Lock, unlock object. Special stuff for opening clam/oyster * and for chain. */ - if (obj == CLAM || obj == OYSTER) - return bivalve(verb, obj); - if (obj == DOOR)spk=RUSTY_DOOR; - if (obj == DOOR && game.prop[DOOR] == 1)spk=OK_MAN; - if (obj == CAGE)spk=NO_LOCK; - if (obj == KEYS)spk=CANNOT_UNLOCK; - if (obj == GRATE || obj == CHAIN) { - spk=NO_KEYS; - if (HERE(KEYS)) { - if (obj == CHAIN) - return chain(verb); - if (game.closng) { - spk=EXIT_CLOSED; - if (!game.panic)game.clock2=15; - game.panic=true; - } else { - spk=game.prop[GRATE] ? GRATE_LOCKED : ALREADY_LOCKED; - game.prop[GRATE]=1; - if (verb == LOCK)game.prop[GRATE]=0; - spk=game.prop[GRATE] ? GRATE_UNLOCKED : GRATE_LOCKED; - } - } - } - RSPEAK(spk); + + switch (obj) { + case CHAIN: + if (HERE(KEYS)) { + return chain(verb); + } else + rspeak(NO_KEYS); + break; + case GRATE: + if (HERE(KEYS)) { + if (game.closng) { + rspeak(EXIT_CLOSED); + if (!game.panic) + game.clock2 = PANICTIME; + game.panic = true; + } else { + state_change(GRATE, (verb == LOCK) ? + GRATE_CLOSED : + GRATE_OPEN); + } + } else + rspeak(NO_KEYS); + break; + case CLAM: + if (verb == LOCK) + rspeak(HUH_MAN); + else if (!TOTING(TRIDENT)) + rspeak(CLAM_OPENER); + else { + DESTROY(CLAM); + drop(OYSTER, game.loc); + drop(PEARL, LOC_CULDESAC); + rspeak(PEARL_FALLS); + } + break; + case OYSTER: + if (verb == LOCK) + rspeak(HUH_MAN); + else if (TOTING(OYSTER)) + rspeak(DROP_OYSTER); + else if (!TOTING(TRIDENT)) + rspeak(OYSTER_OPENER); + else + rspeak(OYSTER_OPENS); + break; + case DOOR: + rspeak((game.prop[DOOR] == DOOR_UNRUSTED) ? OK_MAN : RUSTY_DOOR); + break; + case CAGE: + rspeak( NO_LOCK); + break; + case KEYS: + rspeak(CANNOT_UNLOCK); + break; + default: + speak(actions[verb].message); + } + return GO_CLEAROBJ; } -static int pour(token_t verb, token_t obj) +static int pour(verb_t verb, obj_t obj) /* Pour. If no object, or object is bottle, assume contents of bottle. * special tests for pouring water or oil on plant or rusty door. */ { - int spk = ACTSPK[verb]; - if (obj == BOTTLE || obj == 0)obj=LIQUID(); - if (obj == 0) return GO_UNKNOWN; - if (!TOTING(obj)) {RSPEAK(spk); return GO_CLEAROBJ;} - spk=CANT_POUR; - if (obj != OIL && obj != WATER) {RSPEAK(spk); return GO_CLEAROBJ;} - if (HERE(URN) && game.prop[URN] == 0) - return fill(verb, URN); - game.prop[BOTTLE] = 1; - game.place[obj] = NOWHERE; - spk=GROUND_WET; - if (!(AT(PLANT) || AT(DOOR))) - {RSPEAK(spk); return GO_CLEAROBJ;} + if (obj == BOTTLE || + obj == INTRANSITIVE) + obj = LIQUID(); + if (obj == NO_OBJECT) + return GO_UNKNOWN; + if (!TOTING(obj)) { + speak(actions[verb].message); + return GO_CLEAROBJ; + } + + if (obj != OIL && obj != WATER) { + rspeak(CANT_POUR); + return GO_CLEAROBJ; + } + if (HERE(URN) && game.prop[URN] == URN_EMPTY) + return fill(verb, URN); + game.prop[BOTTLE] = EMPTY_BOTTLE; + game.place[obj] = LOC_NOWHERE; + if (!(AT(PLANT) || + AT(DOOR))) { + rspeak(GROUND_WET); + return GO_CLEAROBJ; + } if (!AT(DOOR)) { - spk=SHAKING_LEAVES; - if (obj != WATER) {RSPEAK(spk); return GO_CLEAROBJ;} - PSPEAK(PLANT,game.prop[PLANT]+3); - game.prop[PLANT]=MOD(game.prop[PLANT]+1,3); - game.prop[PLANT2]=game.prop[PLANT]; - return GO_MOVE; + if (obj == WATER) { + /* cycle through the three plant states */ + state_change(PLANT, MOD(game.prop[PLANT] + 1, 3)); + game.prop[PLANT2] = game.prop[PLANT]; + return GO_MOVE; + } else { + rspeak(SHAKING_LEAVES); + return GO_CLEAROBJ; + } } else { - game.prop[DOOR]=0; - if (obj == OIL)game.prop[DOOR]=1; - spk=RUSTED_HINGES+game.prop[DOOR]; - RSPEAK(spk); - return GO_CLEAROBJ; + state_change(DOOR, (obj == OIL) ? + DOOR_UNRUSTED : + DOOR_RUSTED); + return GO_CLEAROBJ; } } -static int quit(FILE *input) +static int quit(void) /* Quit. Intransitive only. Verify intent and exit if that's what he wants. */ { - if (YES(input,REALLY_QUIT,OK_MAN,OK_MAN)) - score(quitgame); + if (yes(arbitrary_messages[REALLY_QUIT], arbitrary_messages[OK_MAN], arbitrary_messages[OK_MAN])) + terminate(quitgame); return GO_CLEAROBJ; } -static int read(FILE *input, token_t verb, token_t obj) +static int read(command_t command) /* Read. Print stuff based on objtxt. Oyster (?) is special case. */ { - int spk = ACTSPK[verb]; - if (obj == INTRANSITIVE) { - obj = 0; - for (int i=1; i<=NOBJECTS; i++) { - if (HERE(i) && OBJTXT[i] != 0 && game.prop[i] >= 0) - obj = obj * NOBJECTS + i; - } - if (obj > NOBJECTS || obj == 0 || DARK(game.loc)) return GO_UNKNOWN; - } - - if (DARK(game.loc)) { - SETPRM(1,WD1,WD1X); - RSPEAK(NO_SEE); - return GO_CLEAROBJ; - } - if (OBJTXT[obj] == 0 || game.prop[obj] < 0) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - if (obj == OYSTER && !game.clshnt) { - game.clshnt=YES(input,CLUE_QUERY,WAYOUT_CLUE,OK_MAN); - return GO_CLEAROBJ; + if (command.obj == INTRANSITIVE) { + command.obj = NO_OBJECT; + for (int i = 1; i <= NOBJECTS; i++) { + if (HERE(i) && objects[i].texts[0] != NULL && game.prop[i] >= 0) + command.obj = command.obj * NOBJECTS + i; + } + if (command.obj > NOBJECTS || + command.obj == NO_OBJECT || + DARK(game.loc)) + return GO_UNKNOWN; } - PSPEAK(obj,OBJTXT[obj]+game.prop[obj]); + + if (DARK(game.loc)) { + sspeak(NO_SEE, command.word[0].raw); + } else if (command.obj == OYSTER && !game.clshnt && game.closed) { + game.clshnt = yes(arbitrary_messages[CLUE_QUERY], arbitrary_messages[WAYOUT_CLUE], arbitrary_messages[OK_MAN]); + } else if (objects[command.obj].texts[0] == NULL || + game.prop[command.obj] == STATE_NOTFOUND) { + speak(actions[command.verb].message); + } else + pspeak(command.obj, study, game.prop[command.obj], true); return GO_CLEAROBJ; } static int reservoir(void) /* Z'ZZZ (word gets recomputed at startup; different each game). */ { - if (!AT(RESER) && game.loc != game.fixed[RESER]-1) { - RSPEAK(RUB_NOGO); - return GO_CLEAROBJ; + if (!AT(RESER) && game.loc != LOC_RESBOTTOM) { + rspeak(NOTHING_HAPPENS); + return GO_CLEAROBJ; } else { - PSPEAK(RESER,game.prop[RESER]+1); - game.prop[RESER]=1-game.prop[RESER]; - if (AT(RESER)) - return GO_CLEAROBJ; - else { - game.oldlc2=game.loc; - game.newloc=0; - RSPEAK(NOT_BRIGHT); - return GO_TERMINATE; - } + state_change(RESER, + game.prop[RESER] == WATERS_PARTED ? WATERS_UNPARTED : WATERS_PARTED); + if (AT(RESER)) + return GO_CLEAROBJ; + else { + game.oldlc2 = game.loc; + game.newloc = LOC_NOWHERE; + rspeak(NOT_BRIGHT); + return GO_TERMINATE; + } } } -static int rub(token_t verb, token_t obj) +static int rub(verb_t verb, obj_t obj) /* Rub. Yields various snide remarks except for lit urn. */ { - int spk = ACTSPK[verb]; - if (obj != LAMP) - spk=PECULIAR_NOTHING; - if (obj == URN && game.prop[URN] == 2) { - DESTROY(URN); - DROP(AMBER,game.loc); - game.prop[AMBER]=1; - --game.tally; - DROP(CAVITY,game.loc); - spk=URN_GENIES; - } - RSPEAK(spk); + if (obj == URN && game.prop[URN] == URN_LIT) { + DESTROY(URN); + drop(AMBER, game.loc); + game.prop[AMBER] = AMBER_IN_ROCK; + --game.tally; + drop(CAVITY, game.loc); + rspeak(URN_GENIES); + } else if (obj != LAMP) { + rspeak(PECULIAR_NOTHING); + } else { + speak(actions[verb].message); + } return GO_CLEAROBJ; } -static int say(void) -/* Say. Echo WD2 (or WD1 if no WD2 (SAY WHAT?, etc.).) Magic words override. */ +static int say(command_t command) +/* Say. Echo WD2. Magic words override. */ { - /* FIXME: ugly use of globals */ - SETPRM(1,WD2,WD2X); - if (WD2 <= 0) - SETPRM(1,WD1,WD1X); - if (WD2 > 0) - WD1=WD2; - int wd=VOCAB(WD1,-1); - /* FIXME: Magic numbers */ - if (wd == 62 || wd == 65 || wd == 71 || wd == 2025 || wd == 2034) { - WD2=0; - return GO_LOOKUP; - } - RSPEAK(OKEY_DOKEY); - return GO_CLEAROBJ; + if (command.word[1].type == MOTION && + (command.word[1].id == XYZZY || + command.word[1].id == PLUGH || + command.word[1].id == PLOVER)) { + return GO_WORD2; + } + if (command.word[1].type == ACTION && command.word[1].id == PART) + return reservoir(); + if (command.word[1].type == ACTION && + (command.word[1].id == FEE || + command.word[1].id == FIE || + command.word[1].id == FOE || + command.word[1].id == FOO || + command.word[1].id == FUM || + command.word[1].id == PART)) { + return bigwords(command.word[1].id); + } + sspeak(OKEY_DOKEY, command.word[1].raw); + return GO_CLEAROBJ; } -static int throw_support(long spk) +static int throw_support(vocab_t spk) { - RSPEAK(spk); - DROP(AXE,game.loc); + rspeak(spk); + drop(AXE, game.loc); return GO_MOVE; } -static int throw(FILE *cmdin, long verb, token_t obj) +static int throw (command_t command) /* Throw. Same as discard unless axe. Then same as attack except * ignore bird, and if dwarf is present then one might be killed. * (Only way to do so!) Axe also special for dragon, bear, and * troll. Treasures special for troll. */ { - int spk = ACTSPK[verb]; - if (TOTING(ROD2) && obj == ROD && !TOTING(ROD))obj=ROD2; - if (!TOTING(obj)) { - RSPEAK(spk); - return GO_CLEAROBJ; + if (!TOTING(command.obj)) { + speak(actions[command.verb].message); + return GO_CLEAROBJ; } - if (obj >= MINTRS && obj <= MAXTRS && AT(TROLL)) { - spk=TROLL_SATISFIED; + if (objects[command.obj].is_treasure && AT(TROLL)) { /* Snarf a treasure for the troll. */ - DROP(obj,0); - MOVE(TROLL,0); - MOVE(TROLL+NOBJECTS,0); - DROP(TROLL2,PLAC[TROLL]); - DROP(TROLL2+NOBJECTS,FIXD[TROLL]); - JUGGLE(CHASM); - RSPEAK(spk); - return GO_CLEAROBJ; - } - if (obj == FOOD && HERE(BEAR)) { - /* But throwing food is another story. */ - obj=BEAR; - return(feed(verb, obj)); - } - if (obj != AXE) - return(discard(verb, obj, false)); - int i=ATDWRF(game.loc); - if (i <= 0) { - if (AT(DRAGON) && game.prop[DRAGON] == 0) { - spk=DRAGON_SCALES; - return throw_support(spk); - } - if (AT(TROLL)) { - spk=TROLL_RETURNS; - return throw_support(spk); - } - if (AT(OGRE)) { - spk=OGRE_DODGE; - return throw_support(spk); + drop(command.obj, LOC_NOWHERE); + move(TROLL, LOC_NOWHERE); + move(TROLL + NOBJECTS, IS_FREE); + drop(TROLL2, objects[TROLL].plac); + drop(TROLL2 + NOBJECTS, objects[TROLL].fixd); + juggle(CHASM); + rspeak(TROLL_SATISFIED); + return GO_CLEAROBJ; + } + if (command.obj == FOOD && HERE(BEAR)) { + /* But throwing food is another story. */ + command.obj = BEAR; + return (feed(command.verb, command.obj)); + } + if (command.obj != AXE) + return (discard(command.verb, command.obj)); + else { + if (atdwrf(game.loc) <= 0) { + if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) + return throw_support(DRAGON_SCALES); + if (AT(TROLL)) + return throw_support(TROLL_RETURNS); + if (AT(OGRE)) + return throw_support(OGRE_DODGE); + if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) { + /* This'll teach him to throw the axe at the bear! */ + drop(AXE, game.loc); + game.fixed[AXE] = IS_FIXED; + juggle(BEAR); + state_change(AXE, AXE_LOST); + return GO_CLEAROBJ; + } + command.obj = INTRANSITIVE; + return (attack(command)); } - if (HERE(BEAR) && game.prop[BEAR] == 0) { - /* This'll teach him to throw the axe at the bear! */ - spk=AXE_LOST; - DROP(AXE,game.loc); - game.fixed[AXE]= -1; - game.prop[AXE]=1; - JUGGLE(BEAR); - {RSPEAK(spk); return GO_CLEAROBJ;} + + if (randrange(NDWARVES + 1) < game.dflag) { + return throw_support(DWARF_DODGES); + } else { + int i = atdwrf(game.loc); + game.dseen[i] = false; + game.dloc[i] = LOC_NOWHERE; + return throw_support((++game.dkill == 1) ? + DWARF_SMOKE : + KILLED_DWARF); } - return(attack(cmdin, verb, 0)); } +} - if (randrange(NDWARVES+1) < game.dflag) { - spk=DWARF_DODGES; - return throw_support(spk); +static int wake(verb_t verb, obj_t obj) +/* Wake. Only use is to disturb the dwarves. */ +{ + if (obj != DWARF || + !game.closed) { + speak(actions[verb].message); + return GO_CLEAROBJ; + } else { + rspeak(PROD_DWARF); + return GO_DWARFWAKE; } - game.dseen[i]=false; - game.dloc[i]=0; - spk=KILLED_DWARF; - ++game.dkill; - if (game.dkill == 1)spk=DWARF_SMOKE; - - return throw_support(spk); } -static int vscore(void) -/* Score. Call scoring routine but tell it to return. */ +static int seed(verb_t verb, const char *arg) +/* Set seed */ { - score(scoregame); - return GO_CLEAROBJ; + int32_t seed = strtol(arg, NULL, 10); + speak(actions[verb].message, seed); + set_seed(seed); + --game.turns; + return GO_TOP; } -static int wake(token_t verb, token_t obj) -/* Wake. Only use is to disturb the dwarves. */ +static int waste(verb_t verb, turn_t turns) +/* Burn turns */ { - if (obj != DWARF || !game.closed) - { - RSPEAK(ACTSPK[verb]); - return GO_CLEAROBJ; - } - RSPEAK(PROD_DWARF); - return GO_DWARFWAKE; + game.limit -= turns; + speak(actions[verb].message, (int)game.limit); + return GO_TOP; } -static int wave(token_t verb, token_t obj) +static int wave(verb_t verb, obj_t obj) /* Wave. No effect unless waving rod at fissure or at bird. */ { - int spk = ACTSPK[verb]; - if ((!TOTING(obj)) && (obj != ROD || !TOTING(ROD2)))spk=ARENT_CARRYING; if (obj != ROD || - !TOTING(obj) || - (!HERE(BIRD) && (game.closng || !AT(FISSUR)))) { - RSPEAK(spk); - return GO_CLEAROBJ; - } - if (HERE(BIRD))spk=FREE_FLY+MOD(game.prop[BIRD],2); - if (spk == 206 && game.loc == game.place[STEPS] && game.prop[JADE] < 0) { - DROP(JADE,game.loc); - game.prop[JADE]=0; - --game.tally; - spk=NECKLACE_FLY; - RSPEAK(spk); - return GO_CLEAROBJ; + !TOTING(obj) || + (!HERE(BIRD) && + (game.closng || + !AT(FISSURE)))) { + speak(((!TOTING(obj)) && (obj != ROD || + !TOTING(ROD2))) ? + arbitrary_messages[ARENT_CARRYING] : + actions[verb].message); + return GO_CLEAROBJ; + } + + if (game.prop[BIRD] == BIRD_UNCAGED && game.loc == game.place[STEPS] && game.prop[JADE] == STATE_NOTFOUND) { + drop(JADE, game.loc); + game.prop[JADE] = STATE_FOUND; + --game.tally; + rspeak(NECKLACE_FLY); + return GO_CLEAROBJ; } else { - if (game.closed) { - RSPEAK(spk); - return GO_DWARFWAKE; - } - if (game.closng || !AT(FISSUR)) {RSPEAK(spk); return GO_CLEAROBJ;} - if (HERE(BIRD))RSPEAK(spk); - game.prop[FISSUR]=1-game.prop[FISSUR]; - PSPEAK(FISSUR,2-game.prop[FISSUR]); - return GO_CLEAROBJ; + if (game.closed) { + rspeak((game.prop[BIRD] == BIRD_CAGED) ? + CAGE_FLY : + FREE_FLY); + return GO_DWARFWAKE; + } + if (game.closng || + !AT(FISSURE)) { + rspeak((game.prop[BIRD] == BIRD_CAGED) ? + CAGE_FLY : + FREE_FLY); + return GO_CLEAROBJ; + } + if (HERE(BIRD)) + rspeak((game.prop[BIRD] == BIRD_CAGED) ? + CAGE_FLY : + FREE_FLY); + + state_change(FISSURE, + game.prop[FISSURE] == BRIDGED ? UNBRIDGED : BRIDGED); + return GO_CLEAROBJ; } } -int action(FILE *input, enum speechpart part, long verb, token_t obj) +int action(command_t command) /* Analyse a verb. Remember what it was, go back for object if second word * unless verb is "say", which snarfs arbitrary second word. */ { - token_t spk=ACTSPK[verb]; - - if (part == unknown) - { - /* Analyse an object word. See if the thing is here, whether - * we've got a verb yet, and so on. Object must be here - * unless verb is "find" or "invent(ory)" (and no new verb - * yet to be analysed). Water and oil are also funny, since - * they are never actually dropped at any location, but might - * be here inside the bottle or urn or as a feature of the - * location. */ - if (HERE(obj)) - /* FALL THROUGH */; - else if (obj == GRATE) { - if (game.loc == LOC_START || game.loc == LOC_VALLEY || game.loc == LOC_SLIT) - obj=DPRSSN; - /* FIXME: Arithmetic on location numbers */ - if (game.loc > LOC_BELOWGRATE && game.loc < LOC_MISTHALL) - obj=ENTRNC; - if (obj != GRATE) - return GO_MOVE; - } - else if (obj == DWARF && ATDWRF(game.loc) > 0) - /* FALL THROUGH */; - else if ((LIQUID() == obj && HERE(BOTTLE)) || obj == LIQLOC(game.loc)) - /* FALL THROUGH */; - else if (obj == OIL && HERE(URN) && game.prop[URN] != 0) { - obj=URN; - /* FALL THROUGH */; - } - else if (obj == PLANT && AT(PLANT2) && game.prop[PLANT2] != 0) { - obj=PLANT2; - /* FALL THROUGH */; - } - else if (obj == KNIFE && game.knfloc == game.loc) { - game.knfloc= -1; - spk=KNIVES_VANISH; - RSPEAK(spk); - return GO_CLEAROBJ; - } - else if (obj == ROD && HERE(ROD2)) { - obj=ROD2; - /* FALL THROUGH */; - } - else if ((verb == FIND || verb == INVENT) && WD2 <= 0) - /* FALL THROUGH */; - else { - SETPRM(1,WD1,WD1X); - RSPEAK(NO_SEE); - return GO_CLEAROBJ; - } - - if (WD2 > 0) - return GO_WORD2; - if (verb != 0) - part = transitive; - } - - switch(part) - { - case intransitive: - if (WD2 > 0 && verb != SAY) return(2800); - if (verb == SAY)obj=WD2; - if (obj == 0 || obj == INTRANSITIVE) { - /* Analyse an intransitive verb (ie, no object given yet). */ - switch (verb-1) { - case 0: /* CARRY */ return carry(verb, INTRANSITIVE); - case 1: /* DROP */ return GO_UNKNOWN; - case 2: /* SAY */ return GO_UNKNOWN; - case 3: /* UNLOC */ return lock(verb, INTRANSITIVE); - case 4: /* NOTHI */ {RSPEAK(OK_MAN); return(GO_CLEAROBJ);} - case 5: /* LOCK */ return lock(verb, INTRANSITIVE); - case 6: /* LIGHT */ return light(verb, INTRANSITIVE); - case 7: /* EXTIN */ return extinguish(verb, INTRANSITIVE); - case 8: /* WAVE */ return GO_UNKNOWN; - case 9: /* CALM */ return GO_UNKNOWN; - case 10: /* WALK */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 11: /* ATTAC */ return attack(input, verb, obj); - case 12: /* POUR */ return pour(verb, obj); - case 13: /* EAT */ return eat(verb, INTRANSITIVE); - case 14: /* DRINK */ return drink(verb, obj); - case 15: /* RUB */ return GO_UNKNOWN; - case 16: /* TOSS */ return GO_UNKNOWN; - case 17: /* QUIT */ return quit(input); - case 18: /* FIND */ return GO_UNKNOWN; - case 19: /* INVEN */ return inven(); - case 20: /* FEED */ return GO_UNKNOWN; - case 21: /* FILL */ return fill(verb, obj); - case 22: /* BLAST */ return blast(); - case 23: /* SCOR */ return vscore(); - case 24: /* FOO */ return bigwords(WD1); - case 25: /* BRIEF */ return brief(); - case 26: /* READ */ return read(input, verb, INTRANSITIVE); - case 27: /* BREAK */ return GO_UNKNOWN; - case 28: /* WAKE */ return GO_UNKNOWN; - case 29: /* SUSP */ return saveresume(input, false); - case 30: /* RESU */ return saveresume(input, true); - case 31: /* FLY */ return fly(verb, INTRANSITIVE); - case 32: /* LISTE */ return listen(); - case 33: /* ZZZZ */ return reservoir(); - } - BUG(23); - } - /* FALLTHRU */ - case transitive: - /* Analyse a transitive verb. */ - switch (verb-1) { - case 0: /* CARRY */ return carry(verb, obj); - case 1: /* DROP */ return discard(verb, obj, false); - case 2: /* SAY */ return say(); - case 3: /* UNLOC */ return lock(verb, obj); - case 4: /* NOTHI */ {RSPEAK(OK_MAN); return(GO_CLEAROBJ);} - case 5: /* LOCK */ return lock(verb, obj); - case 6: /* LIGHT */ return light(verb, obj); - case 7: /* EXTI */ return extinguish(verb, obj); - case 8: /* WAVE */ return wave(verb, obj); - case 9: /* CALM */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 10: /* WALK */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 11: /* ATTAC */ return attack(input, verb, obj); - case 12: /* POUR */ return pour(verb, obj); - case 13: /* EAT */ return eat(verb, obj); - case 14: /* DRINK */ return drink(verb, obj); - case 15: /* RUB */ return rub(verb, obj); - case 16: /* TOSS */ return throw(input, verb, obj); - case 17: /* QUIT */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 18: /* FIND */ return find(verb, obj); - case 19: /* INVEN */ return find(verb, obj); - case 20: /* FEED */ return feed(verb, obj); - case 21: /* FILL */ return fill(verb, obj); - case 22: /* BLAST */ return blast(); - case 23: /* SCOR */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 24: /* FOO */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 25: /* BRIEF */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 26: /* READ */ return read(input, verb, obj); - case 27: /* BREAK */ return vbreak(verb, obj); - case 28: /* WAKE */ return wake(verb, obj); - case 29: /* SUSP */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 30: /* RESU */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 31: /* FLY */ return fly(verb, obj); - case 32: /* LISTE */ {RSPEAK(spk); return GO_CLEAROBJ;} - case 33: /* ZZZZ */ return reservoir(); - } - BUG(24); - case unknown: - /* Unknown verb, couldn't deduce object - might need hint */ - SETPRM(1,WD1,WD1X); - RSPEAK(WHAT_DO); - return GO_CHECKHINT; - default: - BUG(99); + /* Previously, actions that result in a message, but don't do anything + * further were called "specials". Now they're handled here as normal + * actions. If noaction is true, then we spit out the message and return */ + if (actions[command.verb].noaction) { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + + if (command.part == unknown) { + /* Analyse an object word. See if the thing is here, whether + * we've got a verb yet, and so on. Object must be here + * unless verb is "find" or "invent(ory)" (and no new verb + * yet to be analysed). Water and oil are also funny, since + * they are never actually dropped at any location, but might + * be here inside the bottle or urn or as a feature of the + * location. */ + if (HERE(command.obj)) + /* FALL THROUGH */; + else if (command.obj == DWARF && atdwrf(game.loc) > 0) + /* FALL THROUGH */; + else if ((LIQUID() == command.obj && HERE(BOTTLE)) || + command.obj == LIQLOC(game.loc)) + /* FALL THROUGH */; + else if (command.obj == OIL && HERE(URN) && game.prop[URN] != URN_EMPTY) { + command.obj = URN; + /* FALL THROUGH */; + } else if (command.obj == PLANT && AT(PLANT2) && game.prop[PLANT2] != PLANT_THIRSTY) { + command.obj = PLANT2; + /* FALL THROUGH */; + } else if (command.obj == KNIFE && game.knfloc == game.loc) { + game.knfloc = -1; + rspeak(KNIVES_VANISH); + return GO_CLEAROBJ; + } else if (command.obj == ROD && HERE(ROD2)) { + command.obj = ROD2; + /* FALL THROUGH */; + } else if ((command.verb == FIND || + command.verb == INVENTORY) && (command.word[1].id == WORD_EMPTY || command.word[1].id == WORD_NOT_FOUND)) + /* FALL THROUGH */; + else { + sspeak(NO_SEE, command.word[0].raw); + return GO_CLEAROBJ; + } + + if (command.verb != 0) + command.part = transitive; + } + + switch (command.part) { + case intransitive: + if (command.word[1].raw[0] != '\0' && command.verb != SAY) + return GO_WORD2; + if (command.verb == SAY) + /* KEYS is not special, anything not NO_OBJECT or INTRANSITIVE + * will do here. We're preventing interpretation as an intransitive + * verb when the word is unknown. */ + command.obj = command.word[1].raw[0] != '\0' ? KEYS : NO_OBJECT; + if (command.obj == NO_OBJECT || + command.obj == INTRANSITIVE) { + /* Analyse an intransitive verb (ie, no object given yet). */ + switch (command.verb) { + case CARRY: + return vcarry(command.verb, INTRANSITIVE); + case DROP: + return GO_UNKNOWN; + case SAY: + return GO_UNKNOWN; + case UNLOCK: + return lock(command.verb, INTRANSITIVE); + case NOTHING: { + rspeak(OK_MAN); + return (GO_CLEAROBJ); + } + case LOCK: + return lock(command.verb, INTRANSITIVE); + case LIGHT: + return light(command.verb, INTRANSITIVE); + case EXTINGUISH: + return extinguish(command.verb, INTRANSITIVE); + case WAVE: + return GO_UNKNOWN; + case TAME: + return GO_UNKNOWN; + case GO: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case ATTACK: + command.obj = INTRANSITIVE; + return attack(command); + case POUR: + return pour(command.verb, INTRANSITIVE); + case EAT: + return eat(command.verb, INTRANSITIVE); + case DRINK: + return drink(command.verb, INTRANSITIVE); + case RUB: + return GO_UNKNOWN; + case THROW: + return GO_UNKNOWN; + case QUIT: + return quit(); + case FIND: + return GO_UNKNOWN; + case INVENTORY: + return inven(); + case FEED: + return GO_UNKNOWN; + case FILL: + return fill(command.verb, INTRANSITIVE); + case BLAST: + blast(); + return GO_CLEAROBJ; + case SCORE: + score(scoregame); + return GO_CLEAROBJ; + case FEE: + case FIE: + case FOE: + case FOO: + case FUM: + return bigwords(command.word[0].id); + case BRIEF: + return brief(); + case READ: + command.obj = INTRANSITIVE; + return read(command); + case BREAK: + return GO_UNKNOWN; + case WAKE: + return GO_UNKNOWN; + case SAVE: + return suspend(); + case RESUME: + return resume(); + case FLY: + return fly(command.verb, INTRANSITIVE); + case LISTEN: + return listen(); + case PART: + return reservoir(); + case SEED: + case WASTE: + rspeak(NUMERIC_REQUIRED); + return GO_TOP; + default: // LCOV_EXCL_LINE + BUG(INTRANSITIVE_ACTION_VERB_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE + } + } + /* FALLTHRU */ + case transitive: + /* Analyse a transitive verb. */ + switch (command.verb) { + case CARRY: + return vcarry(command.verb, command.obj); + case DROP: + return discard(command.verb, command.obj); + case SAY: + return say(command); + case UNLOCK: + return lock(command.verb, command.obj); + case NOTHING: { + rspeak(OK_MAN); + return (GO_CLEAROBJ); + } + case LOCK: + return lock(command.verb, command.obj); + case LIGHT: + return light(command.verb, command.obj); + case EXTINGUISH: + return extinguish(command.verb, command.obj); + case WAVE: + return wave(command.verb, command.obj); + case TAME: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case GO: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case ATTACK: + return attack(command); + case POUR: + return pour(command.verb, command.obj); + case EAT: + return eat(command.verb, command.obj); + case DRINK: + return drink(command.verb, command.obj); + case RUB: + return rub(command.verb, command.obj); + case THROW: + return throw (command); + case QUIT: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case FIND: + return find(command.verb, command.obj); + case INVENTORY: + return find(command.verb, command.obj); + case FEED: + return feed(command.verb, command.obj); + case FILL: + return fill(command.verb, command.obj); + case BLAST: + blast(); + return GO_CLEAROBJ; + case SCORE: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case FEE: + case FIE: + case FOE: + case FOO: + case FUM: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case BRIEF: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case READ: + return read(command); + case BREAK: + return vbreak(command.verb, command.obj); + case WAKE: + return wake(command.verb, command.obj); + case SAVE: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case RESUME: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + case FLY: + return fly(command.verb, command.obj); + case LISTEN: { + speak(actions[command.verb].message); + return GO_CLEAROBJ; + } + // LCOV_EXCL_START + // This case should never happen - here only as placeholder + case PART: + return reservoir(); + // LCOV_EXCL_STOP + case SEED: + return seed(command.verb, command.word[1].raw); + case WASTE: + return waste(command.verb, (turn_t)atol(command.word[1].raw)); + default: // LCOV_EXCL_LINE + BUG(TRANSITIVE_ACTION_VERB_EXCEEDS_GOTO_LIST); // LCOV_EXCL_LINE + } + case unknown: + /* Unknown verb, couldn't deduce object - might need hint */ + sspeak(WHAT_DO, command.word[0].raw); + return GO_CHECKHINT; + default: // LCOV_EXCL_LINE + BUG(SPEECHPART_NOT_TRANSITIVE_OR_INTRANSITIVE_OR_UNKNOWN); // LCOV_EXCL_LINE } }