#include "linenoise/linenoise.h"
#include "newdb.h"
+#define DIM(a) (sizeof(a)/sizeof(a[0]))
+
+/* Abstract out the encoding of words in the travel array. Gives us
+ * some hope of getting to a less cryptic representation than we
+ * inherited from FORTRAN, someday. To understand these, read the
+ * encoding description for TRAVEL.
+ */
+#define T_DESTINATION(entry) MOD(labs(entry) / 1000, 1000)
+#define T_NODWARVES(entry) labs(entry) / 1000000 == 100
+#define T_MOTION(entry) MOD(labs(entry), 1000)
+#define L_SPEAK(loc) ((loc) - 500)
+#define T_TERMINATE(entry) (T_MOTION(entry) == 1)
+
struct game_t game;
long LNLENG, LNPOSN;
* notes). */
static void checkhints(void)
{
- if (COND[game.loc] >= game.conds) {
- for (int hint = 0; hint < HINT_COUNT; hint++) {
+ if (conditions[game.loc] >= game.conds) {
+ for (int hint = 0; hint < NHINTS; hint++) {
if (game.hinted[hint])
continue;
- if (!CNDBIT(game.loc, hint + 1 + HBASE))
+ if (!CNDBIT(game.loc, hint + 1 + COND_HBASE))
game.hintlc[hint] = -1;
++game.hintlc[hint];
/* Come here if he's been long enough at required loc(s) for some
switch (hint) {
case 0:
/* cave */
- if (game.prop[GRATE] == 0 && !HERE(KEYS))
+ if (game.prop[GRATE] == GRATE_CLOSED && !HERE(KEYS))
break;
game.hintlc[hint] = 0;
return;
return true;
int snarfed = 0;
bool movechest = false, robplayer = false;
- for (int treasure = MINTRS; treasure <= MAXTRS; treasure++) {
+ for (int treasure = 1; treasure <= NOBJECTS; treasure++) {
+ if (!object_descriptions[treasure].is_treasure)
+ continue;
/* Pirate won't take pyramid from plover room or dark
* room (too easy!). */
- if (treasure == PYRAMID && (game.loc == PLAC[PYRAMID] || game.loc == PLAC[EMERALD])) {
+ if (treasure == PYRAMID && (game.loc == object_descriptions[PYRAMID].plac || game.loc == object_descriptions[EMERALD].plac)) {
continue;
}
if (TOTING(treasure) || HERE(treasure))
}
}
/* Force chest placement before player finds last treasure */
- if (game.tally == 1 && snarfed == 0 && game.place[CHEST] == LOC_NOWHERE && HERE(LAMP) && game.prop[LAMP] == 1) {
+ if (game.tally == 1 && snarfed == 0 && game.place[CHEST] == LOC_NOWHERE && HERE(LAMP) && game.prop[LAMP] == LAMP_BRIGHT) {
rspeak(PIRATE_SPOTTED);
movechest = true;
}
}
if (robplayer) {
rspeak(PIRATE_POUNCES);
- for (int treasure = MINTRS; treasure <= MAXTRS; treasure++) {
- if (!(treasure == PYRAMID && (game.loc == PLAC[PYRAMID] || game.loc == PLAC[EMERALD]))) {
+ for (int treasure = 1; treasure <= NOBJECTS; treasure++) {
+ if (!object_descriptions[treasure].is_treasure)
+ continue;
+ if (!(treasure == PYRAMID && (game.loc == object_descriptions[PYRAMID].plac || game.loc == object_descriptions[EMERALD].plac))) {
if (AT(treasure) && game.fixed[treasure] == 0)
CARRY(treasure, game.loc);
if (TOTING(treasure))
* 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 || FORCED(game.loc) || CNDBIT(game.newloc, NOARRR))
+ if (game.loc == 0 || FORCED(game.loc) || CNDBIT(game.newloc, COND_NOARRR))
return true;
/* Dwarf activity level ratchets up */
* the 5 dwarves. If any of the survivors is at loc,
* replace him with the alternate. */
if (game.dflag == 1) {
- if (!INDEEP(game.loc) || (PCT(95) && (!CNDBIT(game.loc, NOBACK) || PCT(85))))
+ if (!INDEEP(game.loc) || (PCT(95) && (!CNDBIT(game.loc, COND_NOBACK) || PCT(85))))
return true;
game.dflag = 2;
for (int i = 1; i <= 2; i++) {
kk = KEY[game.dloc[i]];
if (kk != 0)
do {
- game.newloc = MOD(labs(TRAVEL[kk]) / 1000, 1000);
+ game.newloc = T_DESTINATION(TRAVEL[kk]);
/* Have we avoided a dwarf encounter? */
bool avoided = (SPECIAL(game.newloc) ||
!INDEEP(game.newloc) ||
game.newloc == game.odloc[i] ||
(j > 1 && game.newloc == tk[j - 1]) ||
- j >= 20 ||
+ j >= DIM(tk) - 1 ||
game.newloc == game.dloc[i] ||
FORCED(game.newloc) ||
- (i == PIRATE && CNDBIT(game.newloc, NOARRR)) ||
- labs(TRAVEL[kk]) / 1000000 == 100);
+ (i == PIRATE && CNDBIT(game.newloc, COND_NOARRR)) ||
+ T_NODWARVES(TRAVEL[kk]));
if (!avoided) {
tk[j++] = game.newloc;
}
/* "You're dead, Jim."
*
* If the current loc is zero, it means the clown got himself killed.
- * We'll allow this maxdie times. maximum_deaths is automatically set based
+ * We'll allow this maxdie times. NDEATHS is automatically set based
* on the number of snide messages available. Each death results in
* a message (81, 83, etc.) which offers reincarnation; if accepted,
* this results in message 82, 84, etc. The last time, if he wants
* death and exit. */
rspeak(DEATH_CLOSING);
terminate(endgame);
- } else if (game.numdie == maximum_deaths || !YES(query, yes_response, arbitrary_messages[OK_MAN]))
+ } else if (game.numdie == NDEATHS || !YES(query, yes_response, arbitrary_messages[OK_MAN]))
terminate(endgame);
else {
game.place[WATER] = game.place[OIL] = LOC_NOWHERE;
if (TOTING(LAMP))
- game.prop[LAMP] = 0;
+ game.prop[LAMP] = LAMP_DARK;
for (int j = 1; j <= NOBJECTS; j++) {
int i = NOBJECTS + 1 - j;
if (TOTING(i)) {
game.oldloc = game.loc;
k2 = 0;
if (motion == game.loc)k2 = FORGOT_PATH;
- if (CNDBIT(game.loc, NOBACK))k2 = TWIST_TURN;
+ if (CNDBIT(game.loc, COND_NOBACK))k2 = TWIST_TURN;
if (k2 == 0) {
for (;;) {
- scratchloc = MOD((labs(TRAVEL[kk]) / 1000), 1000);
+ scratchloc = T_DESTINATION(TRAVEL[kk]);
if (scratchloc != motion) {
if (!SPECIAL(scratchloc)) {
- if (FORCED(scratchloc) && MOD((labs(TRAVEL[KEY[scratchloc]]) / 1000), 1000) == motion)
+ if (FORCED(scratchloc) && T_DESTINATION(TRAVEL[KEY[scratchloc]]) == motion)
k2 = kk;
}
if (TRAVEL[kk] >= 0) {
- ++kk;
+ ++kk; /* go to next travel entry for this location */
continue;
}
- kk = k2;
+ /* we've reached the end of travel entries for game.loc */
+ kk = k2;
if (kk == 0) {
rspeak(NOT_CONNECTED);
return true;
}
}
- motion = MOD(labs(TRAVEL[kk]), 1000);
+ motion = T_MOTION(TRAVEL[kk]);
kk = KEY[game.loc];
break; /* fall through to ordinary travel */
}
game.oldloc = game.loc;
}
- /* ordinary travel */
+ /* Look for a way to fulfil the motion - kk indexes the beginning
+ * of the motion entries for here (game.loc). */
for (;;) {
- scratchloc = labs(TRAVEL[kk]);
- if (MOD(scratchloc, 1000) == 1 || MOD(scratchloc, 1000) == motion)
+ if (T_TERMINATE(TRAVEL[kk]) || T_MOTION(TRAVEL[kk]) == motion)
break;
if (TRAVEL[kk] < 0) {
/* FIXME: Magic numbers! */
- /* Non-applicable motion. Various messages depending on
- * word given. */
+ /* Couldn't find an entry matching the motion word passed
+ * in. Various messages depending on word given. */
int spk = CANT_APPLY;
if (motion >= 43 && motion <= 50)spk = BAD_DIRECTION;
if (motion == 29 || motion == 30)spk = BAD_DIRECTION;
}
++kk;
}
- scratchloc = scratchloc / 1000;
+ scratchloc = labs(TRAVEL[kk]) / 1000;
do {
/*
* and block him. (standard travel entries check for
* game.prop(TROLL)=0.) Special stuff for bear. */
if (game.prop[TROLL] == 1) {
- pspeak(TROLL, 1);
+ pspeak(TROLL,look, 1);
game.prop[TROLL] = 0;
MOVE(TROLL2, 0);
MOVE(TROLL2 + NOBJECTS, 0);
- MOVE(TROLL, PLAC[TROLL]);
- MOVE(TROLL + NOBJECTS, FIXD[TROLL]);
+ MOVE(TROLL, object_descriptions[TROLL].plac);
+ MOVE(TROLL + NOBJECTS, object_descriptions[TROLL].fixd);
JUGGLE(CHASM);
game.newloc = game.loc;
return true;
} else {
- game.newloc = PLAC[TROLL] + FIXD[TROLL] - game.loc;
+ game.newloc = object_descriptions[TROLL].plac + object_descriptions[TROLL].fixd - game.loc;
if (game.prop[TROLL] == 0)game.prop[TROLL] = 1;
if (!TOTING(BEAR)) return true;
rspeak(BRIDGE_COLLAPSE);
}
} while
(false);
- /* FIXME: Arithmetic on location number, becoming a message number */
- rspeak(game.newloc - 500);
+
+ /* Execute a speak rule */
+ rspeak(L_SPEAK(game.newloc));
game.newloc = game.loc;
return true;
}
* to suppress the object descriptions until he's actually moved the
* objects. */
{
- if (game.tally == 0 && INDEEP(game.loc) && game.loc != 33)
+ if (game.tally == 0 && INDEEP(game.loc) && game.loc != LOC_Y2)
--game.clock1;
/* When the first warning comes, we lock the grate, destroy
* know the bivalve is an oyster. *And*, the dwarves must
* have been activated, since we've found chest. */
if (game.clock1 == 0) {
- game.prop[GRATE] = 0;
+ game.prop[GRATE] = GRATE_CLOSED;
game.prop[FISSURE] = 0;
for (int i = 1; i <= NDWARVES; i++) {
game.dseen[i] = false;
}
MOVE(TROLL, 0);
MOVE(TROLL + NOBJECTS, 0);
- MOVE(TROLL2, PLAC[TROLL]);
- MOVE(TROLL2 + NOBJECTS, FIXD[TROLL]);
+ MOVE(TROLL2, object_descriptions[TROLL].plac);
+ MOVE(TROLL2 + NOBJECTS, object_descriptions[TROLL].fixd);
JUGGLE(CHASM);
if (game.prop[BEAR] != 3)DESTROY(BEAR);
game.prop[CHAIN] = 0;
if (game.clock2 == 0) {
/* Once he's panicked, and clock2 has run out, we come here
* to set up the storage room. The room has two locs,
- * hardwired as 115 (ne) and 116 (sw). At the ne end, we
+ * hardwired as LOC_NE and LOC_SW. At the ne end, we
* place empty bottles, a nursery of plants, a bed of
* oysters, a pile of lamps, rods with stars, sleeping
* dwarves, and him. At the sw end we place grate over
* objects he might be carrying (lest he have some which
* could cause trouble, such as the keys). We describe the
* flash of light and trundle back. */
- game.prop[BOTTLE] = PUT(BOTTLE, LOC_NE, 1);
+ 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);
- OBJTXT[OYSTER] = 3;
game.prop[LAMP] = PUT(LAMP, LOC_NE, 0);
game.prop[ROD] = PUT(ROD, LOC_NE, 0);
game.prop[DWARF] = PUT(DWARF, LOC_NE, 0);
* Reuse sign. */
PUT(GRATE, LOC_SW, 0);
PUT(SIGN, LOC_SW, 0);
- ++OBJTXT[SIGN];
+ 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);
static void lampcheck(void)
/* Check game limit and lamp timers */
{
- if (game.prop[LAMP] == 1)
+ if (game.prop[LAMP] == LAMP_BRIGHT)
--game.limit;
/* Another way we can force an end to things is by having the
* here, in which case we replace the batteries and continue.
* Second is for other cases of lamp dying. Eve after it goes
* out, he can explore outside for a while if desired. */
- if (game.limit <= WARNTIME && HERE(BATTERY) && game.prop[BATTERY] == 0 && HERE(LAMP)) {
+ if (game.limit <= WARNTIME && HERE(BATTERY) && game.prop[BATTERY] == FRESH_BATTERIES && HERE(LAMP)) {
rspeak(REPLACE_BATTERIES);
- game.prop[BATTERY] = 1;
+ game.prop[BATTERY] = DEAD_BATTERIES;
if (TOTING(BATTERY))
DROP(BATTERY, game.loc);
game.limit += BATTERYLIFE;
game.lmwarn = false;
} else if (game.limit == 0) {
game.limit = -1;
- game.prop[LAMP] = 0;
+ game.prop[LAMP] = LAMP_DARK;
if (HERE(LAMP))
rspeak(LAMP_OUT);
} else if (game.limit <= WARNTIME) {
game.lmwarn = true;
int spk = GET_BATTERIES;
if (game.place[BATTERY] == LOC_NOWHERE)spk = LAMP_DIM;
- if (game.prop[BATTERY] == 1)spk = MISSING_BATTERYIES;
+ if (game.prop[BATTERY] == DEAD_BATTERIES)
+ spk = MISSING_BATTERIES;
rspeak(spk);
}
}
int kk = game.prop[obj];
if (obj == STEPS && game.loc == game.fixed[STEPS])
kk = 1;
- pspeak(obj, kk);
+ pspeak(obj, look, kk);
}
}
}
* wants to go. If so, the dwarf's blocking his way. If
* coming from place forbidden to pirate (dwarves rooted in
* place) let him get out (and attacked). */
- if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc, NOARRR)) {
+ if (game.newloc != game.loc && !FORCED(game.loc) && !CNDBIT(game.loc, COND_NOARRR)) {
for (size_t i = 1; i <= NDWARVES - 1; i++) {
if (game.odloc[i] == game.newloc && game.dseen[i]) {
game.newloc = game.loc;
* tick game.clock1 unless well into cave (and not at Y2). */
if (game.closed) {
if (game.prop[OYSTER] < 0 && TOTING(OYSTER))
- pspeak(OYSTER, 1);
+ pspeak(OYSTER, look, 1);
for (size_t i = 1; i <= NOBJECTS; i++) {
if (TOTING(i) && game.prop[i] < 0)
game.prop[i] = -1 - game.prop[i];
/* If a turn threshold has been met, apply penalties and tell
* the player about it. */
- for (int i = 0; i < turn_threshold_count; ++i)
+ for (int i = 0; i < NTHRESHOLDS; ++i)
{
if (game.turns == turn_thresholds[i].threshold + 1)
{