X-Git-Url: https://jxself.org/git/?p=open-adventure.git;a=blobdiff_plain;f=actions.c;h=e41c7bf5913b3918c84787af649e55ae6103e8fc;hp=0aa7d9302decd3ed14d01719a5e8441d299b883d;hb=9e2cb3c19196a26af8e20803314f42b69dc0e014;hpb=51b6b52dc88beeb7873939cadfd61770e69259c3 diff --git a/actions.c b/actions.c index 0aa7d93..e41c7bf 100644 --- a/actions.c +++ b/actions.c @@ -6,14 +6,14 @@ static int fill(verb_t, obj_t); -static int attack(struct command_t *command) +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. */ { - verb_t verb = command->verb; - obj_t obj = command->obj; + verb_t verb = command.verb; + obj_t obj = command.obj; if (obj == INTRANSITIVE) { int changes = 0; @@ -101,13 +101,9 @@ static int attack(struct command_t *command) * 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()) { - // FIXME: setting wd1 is a workaround for broken logic - command->wd1 = token_to_packed("Y"); - } else { - // FIXME: setting wd1 is a workaround for broken logic - command->wd1 = token_to_packed("N"); - return GO_CHECKFOO; + if (!silent_yes()) { + speak(arbitrary_messages[NASTY_DRAGON]); + return GO_MOVE; } state_change(DRAGON, DRAGON_DEAD); game.prop[RUG] = RUG_FLOOR; @@ -180,18 +176,18 @@ static int attack(struct command_t *command) return GO_CLEAROBJ; } -static int bigwords(long id) +static int bigwords(vocab_t id) /* FEE FIE FOE FOO (AND FUM). Advance to next state if given in proper order. * 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). */ { - if ((game.foobar == WORD_EMPTY && id == ACTION_WORD(FEE)) || - (game.foobar == ACTION_WORD(FEE) && id == ACTION_WORD(FIE)) || - (game.foobar == ACTION_WORD(FIE) && id == ACTION_WORD(FOE)) || - (game.foobar == ACTION_WORD(FOE) && id == ACTION_WORD(FOO)) || - (game.foobar == ACTION_WORD(FOE) && id == ACTION_WORD(FUM))) { + 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 != ACTION_WORD(FOO)) && (id != ACTION_WORD(FUM))) { + if ((id != FOO) && (id != FUM)) { rspeak(OK_MAN); return GO_CLEAROBJ; } @@ -205,15 +201,14 @@ static int bigwords(long id) * crossing. */ if (game.place[EGGS] == LOC_NOWHERE && game.place[TROLL] == LOC_NOWHERE && game.prop[TROLL] == TROLL_UNPAID) game.prop[TROLL] = TROLL_PAIDONCE; - int k; if (HERE(EGGS)) - k = EGGS_VANISHED; + pspeak(EGGS, look, EGGS_VANISHED, true); else if (game.loc == objects[EGGS].plac) - k = EGGS_HERE; + pspeak(EGGS, look, EGGS_HERE, true); else - k = EGGS_DONE; + pspeak(EGGS, look, EGGS_DONE, true); move(EGGS, objects[EGGS].plac); - pspeak(EGGS, look, k, true); + return GO_CLEAROBJ; } } else { @@ -236,13 +231,16 @@ static void blast(void) !game.closed) rspeak(REQUIRES_DYNAMITE); else { - if (HERE(ROD2)) - game.bonus = SPLATTER_MESSAGE; - else if (game.loc == LOC_NE) - game.bonus = DEFEAT_MESSAGE; - else - game.bonus = VICTORY_MESSAGE; - rspeak(game.bonus); + 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); } } @@ -253,7 +251,7 @@ static int vbreak(verb_t verb, obj_t obj) switch (obj) { case MIRROR: if (game.closed) { - rspeak(BREAK_MIRROR); + state_change(MIRROR, MIRROR_BROKEN); return GO_DWARFWAKE; } else { rspeak(TOO_FAR); @@ -267,6 +265,7 @@ static int vbreak(verb_t verb, obj_t obj) game.fixed[VASE] = IS_FIXED; break; } + /* FALLTHRU */ default: speak(actions[verb].message); } @@ -274,7 +273,7 @@ static int vbreak(verb_t verb, obj_t obj) } 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; @@ -308,40 +307,35 @@ static int vcarry(verb_t verb, obj_t obj) } if (game.fixed[obj] != IS_FREE) { - /* Next guard tests whether plant is tiny or stashed */ - if (obj == PLANT && game.prop[PLANT] <= PLANT_THIRSTY) { - rspeak(DEEP_ROOTS); - return GO_CLEAROBJ; - } - if (obj == BEAR && game.prop[BEAR] == SITTING_BEAR) { - rspeak(BEAR_CHAINED); - return GO_CLEAROBJ; - } - if (obj == CHAIN && game.prop[BEAR] != UNTAMED_BEAR) { - rspeak(STILL_LOCKED); - return GO_CLEAROBJ; - } - if (obj == URN) { + 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); - return GO_CLEAROBJ; - } - if (obj == CAVITY) { + break; + case CAVITY: rspeak(DOUGHNUT_HOLES); - return GO_CLEAROBJ; - } - if (obj == BLOOD) { + break; + case BLOOD: rspeak(FEW_DROPS); - return GO_CLEAROBJ; - } - if (obj == RUG && game.prop[RUG] == RUG_HOVER) { - rspeak(RUG_HOVERS); - return GO_CLEAROBJ; - } - if (obj == SIGN) { + break; + case SIGN: rspeak(HAND_PASSTHROUGH); - return GO_CLEAROBJ; + break; + default: + rspeak(YOU_JOKING); } - rspeak(YOU_JOKING); return GO_CLEAROBJ; } @@ -349,14 +343,14 @@ static int vcarry(verb_t verb, obj_t obj) obj == OIL) { if (!HERE(BOTTLE) || LIQUID() != obj) { - if (TOTING(BOTTLE)) { - if (game.prop[BOTTLE] == EMPTY_BOTTLE) { - return (fill(verb, BOTTLE)); - } else if (game.prop[BOTTLE] != EMPTY_BOTTLE) - rspeak(BOTTLE_FULL); + if (!TOTING(BOTTLE)) { + rspeak(NO_CONTAINER); return GO_CLEAROBJ; } - rspeak(NO_CONTAINER); + if (game.prop[BOTTLE] == EMPTY_BOTTLE) { + return (fill(verb, BOTTLE)); + } else + rspeak(BOTTLE_FULL); return GO_CLEAROBJ; } obj = BOTTLE; @@ -386,12 +380,16 @@ static int vcarry(verb_t verb, obj_t obj) } if ((obj == BIRD || obj == CAGE) && - (game.prop[BIRD] == BIRD_CAGED || STASHED(BIRD) == BIRD_CAGED)) + (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; @@ -418,9 +416,14 @@ static int chain(verb_t verb) 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; } @@ -452,35 +455,28 @@ static int discard(verb_t verb, obj_t obj) * bird (might attack snake or dragon) and cage (might contain bird) and vase. * Drop coins at vending machine for extra batteries. */ { - if (TOTING(ROD2) && obj == ROD && !TOTING(ROD)) + if (obj == ROD && !TOTING(ROD) && TOTING(ROD2)) { obj = ROD2; + } + if (!TOTING(obj)) { speak(actions[verb].message); 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] = SNAKE_CHASED; - } else if ((GSTONE(obj) && AT(CAVITY) && game.prop[CAVITY] != CAVITY_FULL)) { + 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))) { - int spk; if (obj == RUBY) - spk = RUG_SETTLES; + rspeak(RUG_SETTLES); else if (TOTING(RUG)) - spk = RUG_WIGGLES; + rspeak(RUG_WIGGLES); else - spk = RUG_RISES; - rspeak(spk); - if (spk != RUG_WIGGLES) { + 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) @@ -488,45 +484,73 @@ static int discard(verb_t verb, obj_t obj) move(RUG + NOBJECTS, k); } } - } else if (obj == COINS && HERE(VEND)) { + 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; - } else if (obj == BIRD && AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) { - rspeak(BIRD_BURNT); - DESTROY(BIRD); - return GO_CLEAROBJ; - } else if (obj == BEAR && AT(TROLL)) { + } + + 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); - } else if (obj != VASE || - game.loc == objects[PILLOW].plac) { - rspeak(OK_MAN); - } else { - 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; } - int k = LIQUID(); - if (k == obj) - obj = BOTTLE; - if (obj == BOTTLE && k != NO_OBJECT) - game.place[k] = LOC_NOWHERE; - if (obj == CAGE && game.prop[BIRD] == BIRD_CAGED) + + 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; + } + } + + if (obj == CAGE && game.prop[BIRD] == BIRD_CAGED) { drop(BIRD, game.loc); - drop(obj, game.loc); - if (obj != BIRD) + } + + if (obj == BIRD) { + if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) { + rspeak(BIRD_BURNT); + DESTROY(BIRD); + return GO_CLEAROBJ; + } + 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; - game.prop[BIRD] = BIRD_UNCAGED; - if (FOREST(game.loc)) - game.prop[BIRD] = BIRD_FOREST_UNCAGED; + } + + rspeak(OK_MAN); + drop(obj, game.loc); return GO_CLEAROBJ; } @@ -568,6 +592,7 @@ static int eat(verb_t verb, obj_t obj) case INTRANSITIVE: if (!HERE(FOOD)) return GO_UNKNOWN; + /* FALLTHRU */ case FOOD: DESTROY(FOOD); rspeak(THANKS_DELICIOUS); @@ -885,7 +910,7 @@ static int light(verb_t verb, obj_t obj) static int listen(void) /* Listen. Intransitive only. Print stuff based on object sound proprties. */ { - long sound = locations[game.loc].sound; + vocab_t sound = locations[game.loc].sound; if (sound != SILENT) { rspeak(sound); if (!locations[game.loc].loud) @@ -898,11 +923,14 @@ static int listen(void) game.prop[i] < 0) continue; int mi = game.prop[i]; - /* FIXME: Weird magic on object states */ + /* (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; - long packed_zzword = token_to_packed(game.zzword); - pspeak(i, hear, mi, true, packed_zzword); + pspeak(i, hear, mi, true, game.zzword); rspeak(NO_MESSAGE); if (i == BIRD && mi == BIRD_ENDSTATE) DESTROY(BIRD); @@ -961,7 +989,7 @@ static int lock(verb_t verb, obj_t obj) if (verb == LOCK) rspeak(HUH_MAN); else if (!TOTING(TRIDENT)) - rspeak(OYSTER_OPENER); + rspeak(CLAM_OPENER); else { DESTROY(CLAM); drop(OYSTER, game.loc); @@ -972,8 +1000,12 @@ static int lock(verb_t verb, obj_t obj) case OYSTER: if (verb == LOCK) rspeak(HUH_MAN); - else + 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); @@ -1044,7 +1076,7 @@ static int quit(void) return GO_CLEAROBJ; } -static int read(struct command_t command) +static int read(command_t command) /* Read. Print stuff based on objtxt. Oyster (?) is special case. */ { if (command.obj == INTRANSITIVE) { @@ -1060,7 +1092,7 @@ static int read(struct command_t command) } if (DARK(game.loc)) { - sspeak(NO_SEE, command.raw1); + 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 || @@ -1109,53 +1141,51 @@ static int rub(verb_t verb, obj_t obj) return GO_CLEAROBJ; } -static int say(struct command_t *command) -/* 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. */ { - if (command->wd2 > 0) { - command->wd1 = command->wd2; - strcpy(command->raw1, command->raw2); - } - char word1[TOKLEN + 1]; - packed_to_token(command->wd1, word1); - int wd = (int) get_vocab_id(word1); - if (wd == MOTION_WORD(XYZZY) || - wd == MOTION_WORD(PLUGH) || - wd == MOTION_WORD(PLOVER) || - wd == ACTION_WORD(FEE) || - wd == ACTION_WORD(FIE) || - wd == ACTION_WORD(FOE) || - wd == ACTION_WORD(FOO) || - wd == ACTION_WORD(FUM) || - wd == ACTION_WORD(PART)) { - /* FIXME: scribbles on the interpreter's command block */ - wordclear(&command->wd2); - return GO_LOOKUP; - } - sspeak(OKEY_DOKEY, command->raw1); + 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); return GO_MOVE; } -static int throw (struct command_t *command) +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. */ { - if (!TOTING(command->obj)) { - speak(actions[command->verb].message); + if (!TOTING(command.obj)) { + speak(actions[command.verb].message); return GO_CLEAROBJ; } - if (objects[command->obj].is_treasure && AT(TROLL)) { + if (objects[command.obj].is_treasure && AT(TROLL)) { /* Snarf a treasure for the troll. */ - drop(command->obj, LOC_NOWHERE); + drop(command.obj, LOC_NOWHERE); move(TROLL, LOC_NOWHERE); move(TROLL + NOBJECTS, IS_FREE); drop(TROLL2, objects[TROLL].plac); @@ -1164,13 +1194,13 @@ static int throw (struct command_t *command) rspeak(TROLL_SATISFIED); return GO_CLEAROBJ; } - if (command->obj == FOOD && HERE(BEAR)) { + if (command.obj == FOOD && HERE(BEAR)) { /* But throwing food is another story. */ - command->obj = BEAR; - return (feed(command->verb, command->obj)); + command.obj = BEAR; + return (feed(command.verb, command.obj)); } - if (command->obj != AXE) - return (discard(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) @@ -1187,14 +1217,14 @@ static int throw (struct command_t *command) state_change(AXE, AXE_LOST); return GO_CLEAROBJ; } - command->obj = INTRANSITIVE; + command.obj = INTRANSITIVE; return (attack(command)); } if (randrange(NDWARVES + 1) < game.dflag) { return throw_support(DWARF_DODGES); } else { - long i = atdwrf(game.loc); + int i = atdwrf(game.loc); game.dseen[i] = false; game.dloc[i] = LOC_NOWHERE; return throw_support((++game.dkill == 1) ? @@ -1217,6 +1247,24 @@ static int wake(verb_t verb, obj_t obj) } } +static int seed(verb_t verb, const char *arg) +/* Set seed */ +{ + int32_t seed = strtol(arg, NULL, 10); + speak(actions[verb].message, seed); + set_seed(seed); + --game.turns; + return GO_TOP; +} + +static int waste(verb_t verb, turn_t turns) +/* Burn turns */ +{ + game.limit -= turns; + speak(actions[verb].message, (int)game.limit); + return GO_TOP; +} + static int wave(verb_t verb, obj_t obj) /* Wave. No effect unless waving rod at fissure or at bird. */ { @@ -1263,12 +1311,20 @@ static int wave(verb_t verb, obj_t obj) } } -int action(struct command_t *command) +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. */ { - if (command->part == unknown) { + /* 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 @@ -1276,98 +1332,86 @@ int action(struct command_t *command) * 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)) + if (HERE(command.obj)) /* FALL THROUGH */; - else if (command->obj == GRATE) { - if (game.loc == LOC_START || - game.loc == LOC_VALLEY || - game.loc == LOC_SLIT) { - command->obj = DPRSSN; - } - if (game.loc == LOC_COBBLE || - game.loc == LOC_DEBRIS || - game.loc == LOC_AWKWARD || - game.loc == LOC_BIRD || - game.loc == LOC_PITTOP) { - command->obj = ENTRNC; - } - } else if (command->obj == DWARF && atdwrf(game.loc) > 0) + else if (command.obj == DWARF && atdwrf(game.loc) > 0) /* FALL THROUGH */; - else if ((LIQUID() == command->obj && HERE(BOTTLE)) || - command->obj == LIQLOC(game.loc)) + 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; + 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; + } 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) { + } 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; + } else if (command.obj == ROD && HERE(ROD2)) { + command.obj = ROD2; /* FALL THROUGH */; - } else if ((command->verb == FIND || - command->verb == INVENTORY) && command->wd2 <= 0) + } 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->raw1); + sspeak(NO_SEE, command.word[0].raw); return GO_CLEAROBJ; } - if (command->wd2 > 0) - return GO_WORD2; - if (command->verb != 0) - command->part = transitive; + if (command.verb != 0) + command.part = transitive; } - switch (command->part) { + switch (command.part) { case intransitive: - if (command->wd2 > 0 && command->verb != SAY) + if (command.word[1].raw[0] != '\0' && command.verb != SAY) return GO_WORD2; - if (command->verb == SAY) - command->obj = command->wd2; - if (command->obj == NO_OBJECT || - command->obj == INTRANSITIVE) { + 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) { + switch (command.verb) { case CARRY: - return vcarry(command->verb, INTRANSITIVE); + return vcarry(command.verb, INTRANSITIVE); case DROP: return GO_UNKNOWN; case SAY: return GO_UNKNOWN; case UNLOCK: - return lock(command->verb, INTRANSITIVE); + return lock(command.verb, INTRANSITIVE); case NOTHING: { rspeak(OK_MAN); return (GO_CLEAROBJ); } case LOCK: - return lock(command->verb, INTRANSITIVE); + return lock(command.verb, INTRANSITIVE); case LIGHT: - return light(command->verb, INTRANSITIVE); + return light(command.verb, INTRANSITIVE); case EXTINGUISH: - return extinguish(command->verb, INTRANSITIVE); + return extinguish(command.verb, INTRANSITIVE); case WAVE: return GO_UNKNOWN; case TAME: return GO_UNKNOWN; case GO: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case ATTACK: - command->obj = INTRANSITIVE; + command.obj = INTRANSITIVE; return attack(command); case POUR: - return pour(command->verb, INTRANSITIVE); + return pour(command.verb, INTRANSITIVE); case EAT: - return eat(command->verb, INTRANSITIVE); + return eat(command.verb, INTRANSITIVE); case DRINK: - return drink(command->verb, INTRANSITIVE); + return drink(command.verb, INTRANSITIVE); case RUB: return GO_UNKNOWN; case THROW: @@ -1381,7 +1425,7 @@ int action(struct command_t *command) case FEED: return GO_UNKNOWN; case FILL: - return fill(command->verb, INTRANSITIVE); + return fill(command.verb, INTRANSITIVE); case BLAST: blast(); return GO_CLEAROBJ; @@ -1393,12 +1437,12 @@ int action(struct command_t *command) case FOE: case FOO: case FUM: - return bigwords(command->id1); + return bigwords(command.word[0].id); case BRIEF: return brief(); case READ: - command->obj = INTRANSITIVE; - return read(*command); + command.obj = INTRANSITIVE; + return read(command); case BREAK: return GO_UNKNOWN; case WAKE: @@ -1408,76 +1452,80 @@ int action(struct command_t *command) case RESUME: return resume(); case FLY: - return fly(command->verb, INTRANSITIVE); + return fly(command.verb, INTRANSITIVE); case LISTEN: return listen(); case PART: return reservoir(); - default: + 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) { + switch (command.verb) { case CARRY: - return vcarry(command->verb, command->obj); + return vcarry(command.verb, command.obj); case DROP: - return discard(command->verb, command->obj); + return discard(command.verb, command.obj); case SAY: return say(command); case UNLOCK: - return lock(command->verb, command->obj); + return lock(command.verb, command.obj); case NOTHING: { rspeak(OK_MAN); return (GO_CLEAROBJ); } case LOCK: - return lock(command->verb, command->obj); + return lock(command.verb, command.obj); case LIGHT: - return light(command->verb, command->obj); + return light(command.verb, command.obj); case EXTINGUISH: - return extinguish(command->verb, command->obj); + return extinguish(command.verb, command.obj); case WAVE: - return wave(command->verb, command->obj); + return wave(command.verb, command.obj); case TAME: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case GO: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case ATTACK: return attack(command); case POUR: - return pour(command->verb, command->obj); + return pour(command.verb, command.obj); case EAT: - return eat(command->verb, command->obj); + return eat(command.verb, command.obj); case DRINK: - return drink(command->verb, command->obj); + return drink(command.verb, command.obj); case RUB: - return rub(command->verb, command->obj); + return rub(command.verb, command.obj); case THROW: return throw (command); case QUIT: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case FIND: - return find(command->verb, command->obj); + return find(command.verb, command.obj); case INVENTORY: - return find(command->verb, command->obj); + return find(command.verb, command.obj); case FEED: - return feed(command->verb, command->obj); + return feed(command.verb, command.obj); case FILL: - return fill(command->verb, command->obj); + return fill(command.verb, command.obj); case BLAST: blast(); return GO_CLEAROBJ; case SCORE: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case FEE: @@ -1485,43 +1533,50 @@ int action(struct command_t *command) case FOE: case FOO: case FUM: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case BRIEF: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case READ: - return read(*command); + return read(command); case BREAK: - return vbreak(command->verb, command->obj); + return vbreak(command.verb, command.obj); case WAKE: - return wake(command->verb, command->obj); + return wake(command.verb, command.obj); case SAVE: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case RESUME: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } case FLY: - return fly(command->verb, command->obj); + return fly(command.verb, command.obj); case LISTEN: { - speak(actions[command->verb].message); + speak(actions[command.verb].message); return GO_CLEAROBJ; } + // LCOV_EXCL_START + // This case should never happen - here only as placeholder case PART: return reservoir(); - default: + // 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->raw1); - return GO_CHECKHINT; - default: + sspeak(WHAT_DO, command.word[0].raw); + return GO_CLEAROBJ; + default: // LCOV_EXCL_LINE BUG(SPEECHPART_NOT_TRANSITIVE_OR_INTRANSITIVE_OR_UNKNOWN); // LCOV_EXCL_LINE } }