#include <getopt.h>
#include <signal.h>
#include <string.h>
+#include <ctype.h>
#include "advent.h"
#include "dungeon.h"
} else {
restore(rfp);
}
+#else
+ game.novice = yes(arbitrary_messages[WELCOME_YOU], arbitrary_messages[CAVE_NEARBY], arbitrary_messages[NO_MESSAGE]);
+ if (game.novice)
+ game.limit = NOVICELIMIT;
#endif
if (settings.logfp)
game.hintlc[hint] = 0;
return;
case 3: /* maze */
- if (game.atloc[game.loc] == 0 &&
- game.atloc[game.oldloc] == 0 &&
- game.atloc[game.oldlc2] == 0 &&
+ if (game.atloc[game.loc] == NO_OBJECT &&
+ game.atloc[game.oldloc] == NO_OBJECT &&
+ game.atloc[game.oldlc2] == NO_OBJECT &&
game.holdng > 1)
break;
game.hintlc[hint] = 0;
game.hintlc[hint] = 0;
return;
case 7: /* woods */
- if (game.atloc[game.loc] == 0 &&
- game.atloc[game.oldloc] == 0 &&
- game.atloc[game.oldlc2] == 0)
+ if (game.atloc[game.loc] == NO_OBJECT &&
+ game.atloc[game.oldloc] == NO_OBJECT &&
+ game.atloc[game.oldlc2] == NO_OBJECT)
break;
return;
case 8: /* ogre */
* it to the troll, but in that case he's seen the chest
* (game.prop=0). */
if (game.loc == game.chloc ||
- game.prop[CHEST] >= 0)
+ game.prop[CHEST] != STATE_NOTFOUND)
return true;
int snarfed = 0;
bool movechest = false, robplayer = false;
continue;
if (!(treasure == PYRAMID && (game.loc == objects[PYRAMID].plac ||
game.loc == objects[EMERALD].plac))) {
- if (AT(treasure) && game.fixed[treasure] == 0)
+ if (AT(treasure) && game.fixed[treasure] == IS_FREE)
carry(treasure, game.loc);
if (TOTING(treasure))
drop(treasure, game.chloc);
* means dwarves won't follow him into dead end in maze, but
* c'est la vie. They'll wait for him outside the dead
* end. */
- if (game.loc == 0 ||
+ if (game.loc == LOC_NOWHERE ||
FORCED(game.loc) ||
CNDBIT(game.newloc, COND_NOARRR))
return true;
kk = tkey[game.dloc[i]];
if (kk != 0)
do {
- game.newloc = travel[kk].dest;
+ enum desttype_t desttype = travel[kk].desttype;
+ game.newloc = travel[kk].destval;
/* Have we avoided a dwarf encounter? */
- if (SPECIAL(game.newloc))
+ if (desttype != dest_goto)
continue;
else if (!INDEEP(game.newloc))
continue;
static bool traveleq(long a, long b)
/* Are two travel entries equal for purposes of skip after failed condition? */
{
- return (travel[a].cond == travel[b].cond)
- && (travel[a].dest == travel[b].dest);
+ return (travel[a].condtype == travel[b].condtype)
+ && (travel[a].condarg1 == travel[b].condarg1)
+ && (travel[a].condarg2 == travel[b].condarg2)
+ && (travel[a].desttype == travel[b].desttype)
+ && (travel[a].destval == travel[b].destval);
}
/* Given the current location in "game.loc", and a motion verb number in
if (spk == 0) {
int te_tmp = 0;
for (;;) {
- scratchloc = travel[travel_entry].dest;
- if (scratchloc != motion) {
- if (!SPECIAL(scratchloc)) {
- if (FORCED(scratchloc) && travel[tkey[scratchloc]].dest == motion)
+ enum desttype_t desttype = travel[travel_entry].desttype;
+ scratchloc = travel[travel_entry].destval;
+ if (desttype != dest_goto || scratchloc != motion) {
+ if (desttype == dest_goto) {
+ if (FORCED(scratchloc) && travel[tkey[scratchloc]].destval == motion)
te_tmp = travel_entry;
}
if (!travel[travel_entry].stop) {
do {
for (;;) { /* L12 loop */
for (;;) {
- long cond = travel[travel_entry].cond;
- long arg = MOD(cond, 100);
- if (!SPECIAL(cond)) {
+ enum condtype_t condtype = travel[travel_entry].condtype;
+ long condarg1 = travel[travel_entry].condarg1;
+ long condarg2 = travel[travel_entry].condarg2;
+ if (condtype < cond_not) {
/* YAML N and [pct N] conditionals */
- if (cond <= 100) {
- if (cond == 0 ||
- PCT(cond))
+ if (condtype == cond_goto || condtype == cond_pct) {
+ if (condarg1 == 0 ||
+ PCT(condarg1))
break;
/* else fall through */
}
/* YAML [with OBJ] clause */
- if (TOTING(arg) ||
- (cond > 200 && AT(arg)))
+ else if (TOTING(condarg1) ||
+ (condtype == cond_with && AT(condarg1)))
break;
/* else fall through to check [not OBJ STATE] */
- } else if (game.prop[arg] != cond / 100 - 3)
+ } else if (game.prop[condarg1] != condarg2)
break;
/* We arrive here on conditional failure.
}
/* Found an eligible rule, now execute it */
- game.newloc = travel[travel_entry].dest;
- if (!SPECIAL(game.newloc))
+ enum desttype_t desttype = travel[travel_entry].desttype;
+ game.newloc = travel[travel_entry].destval;
+ if (desttype == dest_goto)
return;
- if (game.newloc > 500) {
+ if (desttype == dest_speak) {
/* Execute a speak rule */
- rspeak(L_SPEAK(game.newloc));
+ rspeak(game.newloc);
game.newloc = game.loc;
return;
} else {
- game.newloc -= SPECIALBASE;
switch (game.newloc) {
case 1:
- /* Travel 301. Plover-alcove passage. Can carry only
+ /* Special travel 1. Plover-alcove passage. Can carry only
* emerald. Note: travel table must include "useless"
* entries going through passage, which can never be used
* for actual motion, but can be spotted by "go back". */
- /* FIXME: Arithmetic on location numbers */
- game.newloc = 99 + 100 - game.loc;
+ game.newloc = (game.loc == LOC_PLOVER)
+ ? LOC_ALCOVE
+ : LOC_PLOVER;
if (game.holdng > 1 ||
(game.holdng == 1 && !TOTING(EMERALD))) {
game.newloc = game.loc;
}
return;
case 2:
- /* Travel 302. Plover transport. Drop the
+ /* Special travel 2. Plover transport. Drop the
* emerald (only use special travel if toting
* it), so he's forced to use the plover-passage
* to get it out. Having dropped it, go back and
travel_entry = te_tmp;
continue; /* goto L12 */
case 3:
- /* Travel 303. Troll bridge. Must be done only
- * as special motion so that dwarves won't wander
- * across and encounter the bear. (They won't
- * follow the player there because that region is
- * forbidden to the pirate.) If
+ /* Special travel 3. Troll bridge. Must be done
+ * only as special motion so that dwarves won't
+ * wander across and encounter the bear. (They
+ * won't follow the player there because that
+ * region is forbidden to the pirate.) If
* game.prop(TROLL)=1, he's crossed since paying,
* so step out and block him. (standard travel
* entries check for game.prop(TROLL)=0.) Special
if (game.prop[TROLL] == TROLL_PAIDONCE) {
pspeak(TROLL, look, TROLL_PAIDONCE, true);
game.prop[TROLL] = TROLL_UNPAID;
- move(TROLL2, 0);
- move(TROLL2 + NOBJECTS, 0);
+ move(TROLL2, LOC_NOWHERE);
+ move(TROLL2 + NOBJECTS, IS_FREE);
move(TROLL, objects[TROLL].plac);
move(TROLL + NOBJECTS, objects[TROLL].fixd);
juggle(CHASM);
game.prop[TROLL] = TROLL_PAIDONCE;
if (!TOTING(BEAR))
return;
- rspeak(BRIDGE_COLLAPSE);
- game.prop[CHASM] = BRIDGE_WRECKED;
+ state_change(CHASM, BRIDGE_WRECKED);
game.prop[TROLL] = TROLL_GONE;
drop(BEAR, game.newloc);
- game.fixed[BEAR] = -1;
+ game.fixed[BEAR] = IS_FIXED;
game.prop[BEAR] = BEAR_DEAD;
game.oldlc2 = game.newloc;
croak();
* problems arise from the use of negative prop numbers to suppress
* the object descriptions until he's actually moved the objects. */
{
+ /* Don't tick game.clock1 unless well into cave (and not at Y2). */
if (game.tally == 0 && INDEEP(game.loc) && game.loc != LOC_Y2)
--game.clock1;
game.prop[FISSURE] = UNBRIDGED;
for (int i = 1; i <= NDWARVES; i++) {
game.dseen[i] = false;
- game.dloc[i] = 0;
+ game.dloc[i] = LOC_NOWHERE;
}
- move(TROLL, 0);
- move(TROLL + NOBJECTS, 0);
+ move(TROLL, LOC_NOWHERE);
+ move(TROLL + NOBJECTS, IS_FREE);
move(TROLL2, objects[TROLL].plac);
move(TROLL2 + NOBJECTS, objects[TROLL].fixd);
juggle(CHASM);
if (game.prop[BEAR] != BEAR_DEAD)
DESTROY(BEAR);
game.prop[CHAIN] = CHAIN_HEAP;
- game.fixed[CHAIN] = CHAIN_HEAP;
- game.prop[AXE] = 0;
- game.fixed[AXE] = 0;
+ game.fixed[CHAIN] = IS_FREE;
+ game.prop[AXE] = AXE_HERE;
+ game.fixed[AXE] = IS_FREE;
rspeak(CAVE_CLOSING);
game.clock1 = -1;
game.closng = true;
* could cause trouble, such as the keys). We describe the
* flash of light and trundle back. */
game.prop[BOTTLE] = put(BOTTLE, LOC_NE, EMPTY_BOTTLE);
- game.prop[PLANT] = put(PLANT, LOC_NE, 0);
- game.prop[OYSTER] = put(OYSTER, LOC_NE, 0);
- game.prop[LAMP] = put(LAMP, LOC_NE, 0);
- game.prop[ROD] = put(ROD, LOC_NE, 0);
+ game.prop[PLANT] = put(PLANT, LOC_NE, PLANT_THIRSTY);
+ game.prop[OYSTER] = put(OYSTER, LOC_NE, STATE_FOUND);
+ game.prop[LAMP] = put(LAMP, LOC_NE, LAMP_DARK);
+ game.prop[ROD] = put(ROD, LOC_NE, STATE_FOUND);
game.prop[DWARF] = put(DWARF, LOC_NE, 0);
game.loc = LOC_NE;
game.oldloc = LOC_NE;
put(GRATE, LOC_SW, 0);
put(SIGN, LOC_SW, 0);
game.prop[SIGN] = ENDGAME_SIGN;
- game.prop[SNAKE] = put(SNAKE, LOC_SW, 1);
- game.prop[BIRD] = put(BIRD, LOC_SW, 1);
- game.prop[CAGE] = put(CAGE, LOC_SW, 0);
- game.prop[ROD2] = put(ROD2, LOC_SW, 0);
- game.prop[PILLOW] = put(PILLOW, LOC_SW, 0);
+ game.prop[SNAKE] = put(SNAKE, LOC_SW, SNAKE_CHASED);
+ game.prop[BIRD] = put(BIRD, LOC_SW, BIRD_CAGED);
+ game.prop[CAGE] = put(CAGE, LOC_SW, STATE_FOUND);
+ game.prop[ROD2] = put(ROD2, LOC_SW, STATE_FOUND);
+ game.prop[PILLOW] = put(PILLOW, LOC_SW, STATE_FOUND);
- game.prop[MIRROR] = put(MIRROR, LOC_NE, 0);
+ game.prop[MIRROR] = put(MIRROR, LOC_NE, STATE_FOUND);
game.fixed[MIRROR] = LOC_SW;
for (int i = 1; i <= NOBJECTS; i++) {
if (game.prop[obj] < 0) {
if (game.closed)
continue;
- game.prop[obj] = 0;
+ game.prop[obj] = STATE_FOUND;
if (obj == RUG)
game.prop[RUG] = RUG_DRAGON;
if (obj == CHAIN)
* (so goes the rationalisation). */
}
int kk = game.prop[obj];
- if (obj == STEPS && game.loc == game.fixed[STEPS])
- kk = 1;
+ if (obj == STEPS)
+ kk = (game.loc == game.fixed[STEPS])
+ ? STEPS_UP
+ : STEPS_DOWN;
pspeak(obj, look, kk, true);
}
}
static bool do_command()
/* Get and execute a command */
{
- long V1, V2;
long kmod, defn;
static long igo = 0;
static struct command_t command;
speak(msg);
if (FORCED(game.loc)) {
playermove(HERE);
- return true;
+ return true;
}
if (game.loc == LOC_Y2 && PCT(25) && !game.closng)
rspeak(SAYS_PLUGH);
listobjects();
L2012:
- command.verb = 0;
game.oldobj = command.obj;
- command.obj = 0;
L2600:
checkhints();
/* If closing time, check for any objects being toted with
- * game.prop < 0 and set the prop to -1-game.prop. This way
- * objects won't be described until they've been picked up
- * and put down separate from their respective piles. Don't
- * tick game.clock1 unless well into cave (and not at Y2). */
+ * game.prop < 0 and stash them. This way objects won't be
+ * described until they've been picked up and put down
+ * separate from their respective piles. */
if (game.closed) {
if (game.prop[OYSTER] < 0 && TOTING(OYSTER))
pspeak(OYSTER, look, 1, true);
for (size_t i = 1; i <= NOBJECTS; i++) {
if (TOTING(i) && game.prop[i] < 0)
- game.prop[i] = -1 - game.prop[i];
+ game.prop[i] = STASHED(i);
}
}
game.wzdark = DARK(game.loc);
return (false);
if (word_count(input) > 2) {
rspeak(TWO_WORDS);
+ free(input);
continue;
}
if (strcmp(input, "") != 0)
break;
+ free(input);
}
strncpy(inputbuf, input, LINESIZE - 1);
tokenize(inputbuf, &command);
- /* Every input, check "game.foobar" flag. If zero, nothing's
- * going on. If pos, make neg. If neg, he skipped a word,
- * so make it zero. */
+ char word1[TOKLEN + 1];
+ char word2[TOKLEN + 1];
+ packed_to_token(command.wd1, word1);
+ packed_to_token(command.wd2, word2);
+ command.id1 = get_vocab_id(word1);
+ command.id2 = get_vocab_id(word2);
+
L2607:
- game.foobar = (game.foobar > 0 ? -game.foobar : 0);
++game.turns;
/* If a turn threshold has been met, apply penalties and tell
}
}
- if (command.verb == SAY && command.wd2 > 0)
+ if (command.verb == SAY && command.id2 != WORD_NOT_FOUND && command.id2 != WORD_EMPTY)
command.verb = 0;
if (command.verb == SAY) {
command.part = transitive;
} else
lampcheck();
- char word1[TOKLEN+1];
- char word2[TOKLEN+1];
- packed_to_token(command.wd1, word1);
- packed_to_token(command.wd2, word2);
- V1 = get_vocab_id(word1);
- V2 = get_vocab_id(word2);
- if (V1 == ENTER && (V2 == STREAM ||
- V2 == PROMOTE_WORD(WATER))) {
+ if (command.id1 == ENTER && (command.id2 == STREAM ||
+ command.id2 == PROMOTE_WORD(WATER))) {
if (LIQLOC(game.loc) == WATER) {
rspeak(FEET_WET);
} else {
}
goto L2012;
}
- if (V1 == ENTER && command.wd2 > 0) {
- command.wd1 = command.wd2;
- command.wd1x = command.wd2x;
- wordclear(&command.wd2);
+ if (command.id1 == ENTER && command.id2 != WORD_NOT_FOUND && command.id2 != WORD_EMPTY) {
+ /* command.wd1 = command.wd2; */
+ /* wordclear(&command.wd2); */
+ command.id1 = command.id2;
+ command.id2 = WORD_EMPTY;
} else {
/* FIXME: Magic numbers related to vocabulary */
- if (!((V1 != PROMOTE_WORD(WATER) && V1 != PROMOTE_WORD(OIL)) ||
- (V2 != PROMOTE_WORD(PLANT) && V2 != PROMOTE_WORD(DOOR)))) {
- if (AT(DEMOTE_WORD(V2)))
+ if (!((command.id1 != PROMOTE_WORD(WATER) && command.id1 != PROMOTE_WORD(OIL)) ||
+ (command.id2 != PROMOTE_WORD(PLANT) && command.id2 != PROMOTE_WORD(DOOR)))) {
+ if (AT(DEMOTE_WORD(command.id2)))
command.wd2 = token_to_packed("POUR");
}
- if (V1 == PROMOTE_WORD(CAGE) && V2 == PROMOTE_WORD(BIRD) && HERE(CAGE) && HERE(BIRD))
+ if (command.id1 == PROMOTE_WORD(CAGE) && command.id2 == PROMOTE_WORD(BIRD) && HERE(CAGE) && HERE(BIRD))
command.wd1 = token_to_packed("CATCH");
}
L2620:
Lookup:
packed_to_token(command.wd1, word1);
defn = get_vocab_id(word1);
- if (defn == -1) {
+ if (defn == WORD_NOT_FOUND) {
/* Gee, I don't understand. */
if (fallback_handler(inputbuf))
continue;
- rspeak(DONT_KNOW, command.wd1, command.wd1x);
+ sspeak(DONT_KNOW, command.raw1);
goto L2600;
}
/* FIXME: magic numbers related to vocabulary */
switch (defn / 1000) {
case 0:
playermove(kmod);
- return true;
+ return true;
case 1:
command.part = unknown;
command.obj = kmod;
case GO_WORD2:
/* Get second word for analysis. */
command.wd1 = command.wd2;
- command.wd1x = command.wd2x;
+ strcpy(command.raw1, command.raw2);
wordclear(&command.wd2);
+ command.raw2[0] = '\0';
goto L2620;
case GO_UNKNOWN:
/* Random intransitive verbs come here. Clear obj just in case
* (see attack()). */
- rspeak(DO_WHAT, command.wd1, command.wd1x);
+ command.raw1[0] = toupper(command.raw1[0]);
+ sspeak(DO_WHAT, command.raw1);
command.obj = 0;
goto L2600;
case GO_DWARFWAKE: