obj = SNAKE;
++changes;
}
- if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) {
+ if (AT(DRAGON) && game.objects[DRAGON].prop == DRAGON_BARS) {
obj = DRAGON;
++changes;
}
obj = OGRE;
++changes;
}
- if (HERE(BEAR) && game.prop[BEAR] == UNTAMED_BEAR) {
+ if (HERE(BEAR) && game.objects[BEAR].prop == UNTAMED_BEAR) {
obj = BEAR;
++changes;
}
}
if (obj == VEND) {
state_change(VEND,
- game.prop[VEND] == VEND_BLOCKS ? VEND_UNBLOCKS : VEND_BLOCKS);
+ game.objects[VEND].prop == VEND_BLOCKS ? VEND_UNBLOCKS : VEND_BLOCKS);
return GO_CLEAROBJ;
}
if (obj == BEAR) {
- switch (game.prop[BEAR]) {
+ switch (game.objects[BEAR].prop) {
case UNTAMED_BEAR:
rspeak(BEAR_HANDS);
break;
}
return GO_CLEAROBJ;
}
- if (obj == DRAGON && game.prop[DRAGON] == DRAGON_BARS) {
+ if (obj == DRAGON && game.objects[DRAGON].prop == 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,
return GO_MOVE;
}
state_change(DRAGON, DRAGON_DEAD);
- game.prop[RUG] = RUG_FLOOR;
+ game.objects[RUG].prop = 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
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)
+ if (game.objects[i].place == objects[DRAGON].plac ||
+ game.objects[i].place == objects[DRAGON].fixd)
move(i, LOC_SECRET5);
}
game.loc = LOC_SECRET5;
DESTROY(OGRE);
int dwarves = 0;
for (int i = 1; i < PIRATE; i++) {
- if (game.dloc[i] == game.loc) {
+ if (game.dwarves[i].loc == game.loc) {
++dwarves;
- game.dloc[i] = LOC_LONGWEST;
- game.dseen[i] = false;
+ game.dwarves[i].loc = LOC_LONGWEST;
+ game.dwarves[i].seen = false;
}
}
rspeak((dwarves > 1) ?
return GO_CLEAROBJ;
}
game.foobar = WORD_EMPTY;
- if (game.place[EGGS] == objects[EGGS].plac ||
+ if (game.objects[EGGS].place == 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 (game.objects[EGGS].place == LOC_NOWHERE && game.objects[TROLL].place == LOC_NOWHERE
+ && game.objects[TROLL].prop == TROLL_UNPAID)
+ game.objects[TROLL].prop = TROLL_PAIDONCE;
if (HERE(EGGS))
pspeak(EGGS, look, true, EGGS_VANISHED);
else if (game.loc == objects[EGGS].plac)
return GO_CLEAROBJ;
}
} else {
- /* Magic-word sequebce was started but is incorrect */
- rspeak(START_OVER);
+ /* Magic-word sequence was started but is incorrect */
+ if (settings.oldstyle || game.seenbigwords)
+ rspeak(START_OVER);
+ else
+ rspeak(WELL_POINTLESS);
game.foobar = WORD_EMPTY;
return GO_CLEAROBJ;
}
static void blast(void)
/* Blast. No effect unless you've got dynamite, which is a neat trick! */
{
- if (game.prop[ROD2] == STATE_NOTFOUND ||
- !game.closed)
+ if (PROP_IS_NOTFOUND(ROD2) || !game.closed)
rspeak(REQUIRES_DYNAMITE);
else {
if (HERE(ROD2)) {
break;
}
case VASE:
- if (game.prop[VASE] == VASE_WHOLE) {
+ if (game.objects[VASE].prop == VASE_WHOLE) {
if (TOTING(VASE))
drop(VASE, game.loc);
state_change(VASE, VASE_BROKEN);
- game.fixed[VASE] = IS_FIXED;
+ game.objects[VASE].fixed = IS_FIXED;
break;
}
/* FALLTHRU */
{
if (obj == INTRANSITIVE) {
/* 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 ||
+ if (game.locs[game.loc].atloc == NO_OBJECT ||
+ game.link[game.locs[game.loc].atloc] != 0 ||
atdwrf(game.loc) > 0)
return GO_UNKNOWN;
- obj = game.atloc[game.loc];
+ obj = game.locs[game.loc].atloc;
}
if (TOTING(obj)) {
return GO_CLEAROBJ;
}
- if (game.fixed[obj] != IS_FREE) {
+ if (game.objects[obj].fixed != 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);
+ rspeak(game.objects[PLANT].prop <= PLANT_THIRSTY ? DEEP_ROOTS : YOU_JOKING);
break;
case BEAR:
- rspeak( game.prop[BEAR] == SITTING_BEAR ? BEAR_CHAINED : YOU_JOKING);
+ rspeak( game.objects[BEAR].prop == SITTING_BEAR ? BEAR_CHAINED : YOU_JOKING);
break;
case CHAIN:
- rspeak( game.prop[BEAR] != UNTAMED_BEAR ? STILL_LOCKED : YOU_JOKING);
+ rspeak( game.objects[BEAR].prop != UNTAMED_BEAR ? STILL_LOCKED : YOU_JOKING);
break;
case RUG:
- rspeak(game.prop[RUG] == RUG_HOVER ? RUG_HOVERS : YOU_JOKING);
+ rspeak(game.objects[RUG].prop == RUG_HOVER ? RUG_HOVERS : YOU_JOKING);
break;
case URN:
rspeak(URN_NOBUDGE);
return GO_CLEAROBJ;
}
- if (obj == WATER ||
- obj == OIL) {
- if (!HERE(BOTTLE) ||
- LIQUID() != obj) {
+ 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) {
+ if (game.objects[BOTTLE].prop == EMPTY_BOTTLE) {
return (fill(verb, BOTTLE));
} else
rspeak(BOTTLE_FULL);
}
- if (obj == BIRD && game.prop[BIRD] != BIRD_CAGED && STASHED(BIRD) != BIRD_CAGED) {
- if (game.prop[BIRD] == BIRD_FOREST_UNCAGED) {
+ if (obj == BIRD && game.objects[BIRD].prop != BIRD_CAGED && !PROP_IS_STASHED(BIRD)) {
+ if (game.objects[BIRD].prop == BIRD_FOREST_UNCAGED) {
DESTROY(BIRD);
rspeak(BIRD_CRAP);
return GO_CLEAROBJ;
rspeak(BIRD_EVADES);
return GO_CLEAROBJ;
}
- game.prop[BIRD] = BIRD_CAGED;
+ game.objects[BIRD].prop = BIRD_CAGED;
}
- if ((obj == BIRD ||
- obj == CAGE) &&
- (game.prop[BIRD] == BIRD_CAGED || STASHED(BIRD) == BIRD_CAGED)) {
+ if ((obj == BIRD || obj == CAGE) &&
+ (game.objects[BIRD].prop == BIRD_CAGED || PROP_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;
+ game.objects[LIQUID()].place = CARRIED;
- if (GSTONE(obj) && game.prop[obj] != STATE_FOUND) {
- game.prop[obj] = STATE_FOUND;
- game.prop[CAVITY] = CAVITY_EMPTY;
+ if (GSTONE(obj) && !PROP_IS_FOUND(obj)) {
+ PROP_SET_FOUND(obj);
+ game.objects[CAVITY].prop = CAVITY_EMPTY;
}
rspeak(OK_MAN);
return GO_CLEAROBJ;
/* Do something to the bear's chain */
{
if (verb != LOCK) {
- if (game.prop[BEAR] == UNTAMED_BEAR) {
+ if (game.objects[BEAR].prop == UNTAMED_BEAR) {
rspeak(BEAR_BLOCKS);
return GO_CLEAROBJ;
}
- if (game.prop[CHAIN] == CHAIN_HEAP) {
+ if (game.objects[CHAIN].prop == 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;
+ game.objects[CHAIN].prop = CHAIN_HEAP;
+ game.objects[CHAIN].fixed = IS_FREE;
+ if (game.objects[BEAR].prop != BEAR_DEAD)
+ game.objects[BEAR].prop = CONTENTED_BEAR;
- switch (game.prop[BEAR]) {
+ switch (game.objects[BEAR].prop) {
// 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;
+ game.objects[BEAR].fixed = IS_FIXED;
break;
// LCOV_EXCL_STOP
default:
- game.fixed[BEAR] = IS_FREE;
+ game.objects[BEAR].fixed = IS_FREE;
}
rspeak(CHAIN_UNLOCKED);
return GO_CLEAROBJ;
}
- if (game.prop[CHAIN] != CHAIN_HEAP) {
+ if (game.objects[CHAIN].prop != CHAIN_HEAP) {
rspeak(ALREADY_LOCKED);
return GO_CLEAROBJ;
}
return GO_CLEAROBJ;
}
- game.prop[CHAIN] = CHAIN_FIXED;
+ game.objects[CHAIN].prop = CHAIN_FIXED;
if (TOTING(CHAIN))
drop(CHAIN, game.loc);
- game.fixed[CHAIN] = IS_FIXED;
+ game.objects[CHAIN].fixed = IS_FIXED;
rspeak(CHAIN_LOCKED);
return GO_CLEAROBJ;
return GO_CLEAROBJ;
}
- if (GSTONE(obj) && AT(CAVITY) && game.prop[CAVITY] != CAVITY_FULL) {
+ if (GSTONE(obj) && AT(CAVITY) && game.objects[CAVITY].prop != 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))) {
+ game.objects[obj].prop = STATE_IN_CAVITY;
+ game.objects[CAVITY].prop = CAVITY_FULL;
+ if (HERE(RUG) && ((obj == EMERALD && game.objects[RUG].prop != RUG_HOVER) ||
+ (obj == RUBY && game.objects[RUG].prop == RUG_HOVER))) {
if (obj == RUBY)
rspeak(RUG_SETTLES);
else if (TOTING(RUG))
else
rspeak(RUG_RISES);
if (!TOTING(RUG) || obj == RUBY) {
- int k = (game.prop[RUG] == RUG_HOVER) ? RUG_FLOOR : RUG_HOVER;
- game.prop[RUG] = k;
+ int k = (game.objects[RUG].prop == RUG_HOVER) ? RUG_FLOOR : RUG_HOVER;
+ game.objects[RUG].prop = k;
if (k == RUG_HOVER)
k = objects[SAPPH].plac;
move(RUG + NOBJECTS, k);
if (LIQUID() == obj)
obj = BOTTLE;
if (obj == BOTTLE && LIQUID() != NO_OBJECT) {
- game.place[LIQUID()] = LOC_NOWHERE;
+ game.objects[LIQUID()].place = LOC_NOWHERE;
}
if (obj == BEAR && AT(TROLL)) {
state_change(VASE, AT(PILLOW)
? VASE_WHOLE
: VASE_DROPPED);
- if (game.prop[VASE] != VASE_WHOLE)
- game.fixed[VASE] = IS_FIXED;
+ if (game.objects[VASE].prop != VASE_WHOLE)
+ game.objects[VASE].fixed = IS_FIXED;
drop(obj, game.loc);
return GO_CLEAROBJ;
}
}
- if (obj == CAGE && game.prop[BIRD] == BIRD_CAGED) {
+ if (obj == CAGE && game.objects[BIRD].prop == BIRD_CAGED) {
drop(BIRD, game.loc);
}
if (obj == BIRD) {
- if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS) {
+ if (AT(DRAGON) && game.objects[DRAGON].prop == DRAGON_BARS) {
rspeak(BIRD_BURNT);
DESTROY(BIRD);
return GO_CLEAROBJ;
return GO_DWARFWAKE;
DESTROY(SNAKE);
/* Set game.prop for use by travel options */
- game.prop[SNAKE] = SNAKE_CHASED;
+ game.objects[SNAKE].prop = SNAKE_CHASED;
} else
rspeak(OK_MAN);
- game.prop[BIRD] = FOREST(game.loc) ? BIRD_FOREST_UNCAGED : BIRD_UNCAGED;
+ game.objects[BIRD].prop = FOREST(game.loc) ? BIRD_FOREST_UNCAGED : BIRD_UNCAGED;
drop(obj, game.loc);
return GO_CLEAROBJ;
}
return GO_CLEAROBJ;
}
if (LIQUID() == WATER && HERE(BOTTLE)) {
- game.place[WATER] = LOC_NOWHERE;
+ game.objects[WATER].place = LOC_NOWHERE;
state_change(BOTTLE, EMPTY_BOTTLE);
return GO_CLEAROBJ;
}
/* Extinguish. Lamp, urn, dragon/volcano (nice try). */
{
if (obj == INTRANSITIVE) {
- if (HERE(LAMP) && game.prop[LAMP] == LAMP_BRIGHT)
+ if (HERE(LAMP) && game.objects[LAMP].prop == LAMP_BRIGHT)
obj = LAMP;
- if (HERE(URN) && game.prop[URN] == URN_LIT)
+ if (HERE(URN) && game.objects[URN].prop == URN_LIT)
obj = URN;
if (obj == INTRANSITIVE)
return GO_UNKNOWN;
switch (obj) {
case URN:
- if (game.prop[URN] != URN_EMPTY) {
+ if (game.objects[URN].prop != URN_EMPTY) {
state_change(URN, URN_DARK);
} else {
pspeak(URN, change, true, URN_DARK);
rspeak(BIRD_PINING);
break;
case DRAGON:
- if (game.prop[DRAGON] != DRAGON_BARS)
+ if (game.objects[DRAGON].prop != DRAGON_BARS)
rspeak(RIDICULOUS_ATTEMPT);
else
rspeak(NOTHING_EDIBLE);
speak(actions[verb].message);
break;
case BEAR:
- if (game.prop[BEAR] == BEAR_DEAD) {
+ if (game.objects[BEAR].prop == BEAR_DEAD) {
rspeak(RIDICULOUS_ATTEMPT);
break;
}
- if (game.prop[BEAR] == UNTAMED_BEAR) {
+ if (game.objects[BEAR].prop == UNTAMED_BEAR) {
if (HERE(FOOD)) {
DESTROY(FOOD);
- game.fixed[AXE] = IS_FREE;
- game.prop[AXE] = AXE_HERE;
+ game.objects[AXE].fixed = IS_FREE;
+ game.objects[AXE].prop = AXE_HERE;
state_change(BEAR, SITTING_BEAR);
} else
rspeak(NOTHING_EDIBLE);
return GO_CLEAROBJ;
}
rspeak(SHATTER_VASE);
- game.prop[VASE] = VASE_BROKEN;
- game.fixed[VASE] = IS_FIXED;
+ game.objects[VASE].prop = VASE_BROKEN;
+ game.objects[VASE].fixed = IS_FIXED;
drop(VASE, game.loc);
return GO_CLEAROBJ;
}
if (obj == URN) {
- if (game.prop[URN] != URN_EMPTY) {
+ if (game.objects[URN].prop != URN_EMPTY) {
rspeak(FULL_URN);
return GO_CLEAROBJ;
}
int k = LIQUID();
switch (k) {
case WATER:
- game.prop[BOTTLE] = EMPTY_BOTTLE;
+ game.objects[BOTTLE].prop = EMPTY_BOTTLE;
rspeak(WATER_URN);
break;
case OIL:
- game.prop[URN] = URN_DARK;
- game.prop[BOTTLE] = EMPTY_BOTTLE;
+ game.objects[URN].prop = URN_DARK;
+ game.objects[BOTTLE].prop = EMPTY_BOTTLE;
rspeak(OIL_URN);
break;
case NO_OBJECT:
rspeak(FILL_INVALID);
return GO_CLEAROBJ;
}
- game.place[k] = LOC_NOWHERE;
+ game.objects[k].place = LOC_NOWHERE;
return GO_CLEAROBJ;
}
if (obj != INTRANSITIVE && obj != BOTTLE) {
if (obj == INTRANSITIVE && !HERE(BOTTLE))
return GO_UNKNOWN;
- if (HERE(URN) && game.prop[URN] != URN_EMPTY) {
+ if (HERE(URN) && game.objects[URN].prop != URN_EMPTY) {
rspeak(URN_NOPOUR);
return GO_CLEAROBJ;
}
? OIL_BOTTLE
: WATER_BOTTLE);
if (TOTING(BOTTLE))
- game.place[LIQUID()] = CARRIED;
+ game.objects[LIQUID()].place = CARRIED;
return GO_CLEAROBJ;
}
return GO_CLEAROBJ;
}
- if (AT(obj) ||
- (LIQUID() == obj && AT(BOTTLE)) ||
- obj == LIQLOC(game.loc) ||
- (obj == DWARF && atdwrf(game.loc) > 0)) {
+ if (AT(obj) || (LIQUID() == obj && AT(BOTTLE)) ||
+ obj == LIQLOC(game.loc) || (obj == DWARF && atdwrf(game.loc) > 0)) {
rspeak(YOU_HAVEIT);
return GO_CLEAROBJ;
}
rspeak(FLAP_ARMS);
return GO_CLEAROBJ;
}
- if (game.prop[RUG] != RUG_HOVER) {
+ if (game.objects[RUG].prop != RUG_HOVER) {
rspeak(RUG_NOTHING2);
return GO_CLEAROBJ;
}
speak(actions[verb].message);
return GO_CLEAROBJ;
}
- if (game.prop[RUG] != RUG_HOVER) {
+ if (game.objects[RUG].prop != RUG_HOVER) {
rspeak(RUG_NOTHING1);
return GO_CLEAROBJ;
}
{
bool empty = true;
for (obj_t i = 1; i <= NOBJECTS; i++) {
- if (i == BEAR ||
- !TOTING(i))
+ if (i == BEAR || !TOTING(i))
continue;
if (empty) {
rspeak(NOW_HOLDING);
{
if (obj == INTRANSITIVE) {
int selects = 0;
- if (HERE(LAMP) && game.prop[LAMP] == LAMP_DARK && game.limit >= 0) {
+ if (HERE(LAMP) && game.objects[LAMP].prop == LAMP_DARK && game.limit >= 0) {
obj = LAMP;
selects++;
}
- if (HERE(URN) && game.prop[URN] == URN_DARK) {
+ if (HERE(URN) && game.objects[URN].prop == URN_DARK) {
obj = URN;
selects++;
}
switch (obj) {
case URN:
- state_change(URN, game.prop[URN] == URN_EMPTY ?
+ state_change(URN, game.objects[URN].prop == URN_EMPTY ?
URN_EMPTY :
URN_LIT);
break;
soundlatch = true;
}
for (obj_t i = 1; i <= NOBJECTS; i++) {
- if (!HERE(i) ||
- objects[i].sounds[0] == NULL ||
- game.prop[i] < 0)
+ if (!HERE(i) || objects[i].sounds[0] == NULL || PROP_IS_STASHED_OR_UNSEEN(i))
continue;
- int mi = game.prop[i];
+ int mi = game.objects[i].prop;
/* (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
rspeak(OYSTER_OPENS);
break;
case DOOR:
- rspeak((game.prop[DOOR] == DOOR_UNRUSTED) ? OK_MAN : RUSTY_DOOR);
+ rspeak((game.objects[DOOR].prop == DOOR_UNRUSTED) ? OK_MAN : RUSTY_DOOR);
break;
case CAGE:
rspeak( NO_LOCK);
/* Pour. If no object, or object is bottle, assume contents of bottle.
* special tests for pouring water or oil on plant or rusty door. */
{
- if (obj == BOTTLE ||
- obj == INTRANSITIVE)
- obj = LIQUID();
+ if (obj == BOTTLE || obj == INTRANSITIVE)
+ obj = LIQUID();
if (obj == NO_OBJECT)
return GO_UNKNOWN;
if (!TOTING(obj)) {
rspeak(CANT_POUR);
return GO_CLEAROBJ;
}
- if (HERE(URN) && game.prop[URN] == URN_EMPTY)
+ if (HERE(URN) && game.objects[URN].prop == URN_EMPTY)
return fill(verb, URN);
- game.prop[BOTTLE] = EMPTY_BOTTLE;
- game.place[obj] = LOC_NOWHERE;
- if (!(AT(PLANT) ||
- AT(DOOR))) {
+ game.objects[BOTTLE].prop = EMPTY_BOTTLE;
+ game.objects[obj].place = LOC_NOWHERE;
+ if (!(AT(PLANT) || AT(DOOR))) {
rspeak(GROUND_WET);
return GO_CLEAROBJ;
}
if (!AT(DOOR)) {
if (obj == WATER) {
/* cycle through the three plant states */
- state_change(PLANT, MOD(game.prop[PLANT] + 1, 3));
- game.prop[PLANT2] = game.prop[PLANT];
+ state_change(PLANT, MOD(game.objects[PLANT].prop + 1, 3));
+ game.objects[PLANT2].prop = game.objects[PLANT].prop;
return GO_MOVE;
} else {
rspeak(SHAKING_LEAVES);
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)
+ if (HERE(i) && objects[i].texts[0] != NULL && !PROP_IS_STASHED(i))
command.obj = command.obj * NOBJECTS + i;
}
- if (command.obj > NOBJECTS ||
- command.obj == NO_OBJECT ||
- DARK(game.loc))
+ if (command.obj > NOBJECTS || command.obj == NO_OBJECT || DARK(game.loc))
return GO_UNKNOWN;
}
} else {
pspeak(OYSTER, hear, true, 1); // Not really a sound, but oh well.
}
- } else if (objects[command.obj].texts[0] == NULL ||
- game.prop[command.obj] == STATE_NOTFOUND) {
+ } else if (objects[command.obj].texts[0] == NULL || PROP_IS_NOTFOUND(command.obj)) {
speak(actions[command.verb].message);
} else
- pspeak(command.obj, study, true, game.prop[command.obj]);
+ pspeak(command.obj, study, true, game.objects[command.obj].prop);
return GO_CLEAROBJ;
}
return GO_CLEAROBJ;
} else {
state_change(RESER,
- game.prop[RESER] == WATERS_PARTED ? WATERS_UNPARTED : WATERS_PARTED);
+ game.objects[RESER].prop == WATERS_PARTED ? WATERS_UNPARTED : WATERS_PARTED);
if (AT(RESER))
return GO_CLEAROBJ;
else {
static phase_codes_t rub(verb_t verb, obj_t obj)
/* Rub. Yields various snide remarks except for lit urn. */
{
- if (obj == URN && game.prop[URN] == URN_LIT) {
+ if (obj == URN && game.objects[URN].prop == URN_LIT) {
DESTROY(URN);
drop(AMBER, game.loc);
- game.prop[AMBER] = AMBER_IN_ROCK;
+ game.objects[AMBER].prop = AMBER_IN_ROCK;
--game.tally;
drop(CAVITY, game.loc);
rspeak(URN_GENIES);
return (discard(command.verb, command.obj));
else {
if (atdwrf(game.loc) <= 0) {
- if (AT(DRAGON) && game.prop[DRAGON] == DRAGON_BARS)
+ if (AT(DRAGON) && game.objects[DRAGON].prop == 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) {
+ if (HERE(BEAR) && game.objects[BEAR].prop == UNTAMED_BEAR) {
/* This'll teach him to throw the axe at the bear! */
drop(AXE, game.loc);
- game.fixed[AXE] = IS_FIXED;
+ game.objects[AXE].fixed = IS_FIXED;
juggle(BEAR);
state_change(AXE, AXE_LOST);
return GO_CLEAROBJ;
return throw_support(DWARF_DODGES);
} else {
int i = atdwrf(game.loc);
- game.dseen[i] = false;
- game.dloc[i] = LOC_NOWHERE;
+ game.dwarves[i].seen = false;
+ game.dwarves[i].loc = LOC_NOWHERE;
return throw_support((++game.dkill == 1) ?
DWARF_SMOKE :
KILLED_DWARF);
static phase_codes_t wake(verb_t verb, obj_t obj)
/* Wake. Only use is to disturb the dwarves. */
{
- if (obj != DWARF ||
- !game.closed) {
+ if (obj != DWARF || !game.closed) {
speak(actions[verb].message);
return GO_CLEAROBJ;
} else {
static phase_codes_t wave(verb_t verb, obj_t obj)
/* Wave. No effect unless waving rod at fissure or at bird. */
{
- if (obj != ROD ||
- !TOTING(obj) ||
- (!HERE(BIRD) &&
- (game.closng ||
- !AT(FISSURE)))) {
+ if (obj != ROD || !TOTING(obj) || (!HERE(BIRD) && (game.closng || !AT(FISSURE)))) {
speak(((!TOTING(obj)) && (obj != ROD ||
!TOTING(ROD2))) ?
arbitrary_messages[ARENT_CARRYING] :
return GO_CLEAROBJ;
}
- if (game.prop[BIRD] == BIRD_UNCAGED && game.loc == game.place[STEPS] && game.prop[JADE] == STATE_NOTFOUND) {
+ if (game.objects[BIRD].prop == BIRD_UNCAGED && game.loc == game.objects[STEPS].place
+ && PROP_IS_NOTFOUND(JADE)) {
drop(JADE, game.loc);
- game.prop[JADE] = STATE_FOUND;
+ PROP_SET_FOUND(JADE);
--game.tally;
rspeak(NECKLACE_FLY);
return GO_CLEAROBJ;
} else {
if (game.closed) {
- rspeak((game.prop[BIRD] == BIRD_CAGED) ?
+ rspeak((game.objects[BIRD].prop == BIRD_CAGED) ?
CAGE_FLY :
FREE_FLY);
return GO_DWARFWAKE;
}
- if (game.closng ||
- !AT(FISSURE)) {
- rspeak((game.prop[BIRD] == BIRD_CAGED) ?
+ if (game.closng || !AT(FISSURE)) {
+ rspeak((game.objects[BIRD].prop == BIRD_CAGED) ?
CAGE_FLY :
FREE_FLY);
return GO_CLEAROBJ;
}
if (HERE(BIRD))
- rspeak((game.prop[BIRD] == BIRD_CAGED) ?
+ rspeak((game.objects[BIRD].prop == BIRD_CAGED) ?
CAGE_FLY :
FREE_FLY);
state_change(FISSURE,
- game.prop[FISSURE] == BRIDGED ? UNBRIDGED : BRIDGED);
+ game.objects[FISSURE].prop == BRIDGED ? UNBRIDGED : BRIDGED);
return GO_CLEAROBJ;
}
}
else if (!game.closed && ((LIQUID() == command.obj && HERE(BOTTLE)) ||
command.obj == LIQLOC(game.loc)))
/* FALL THROUGH */;
- else if (command.obj == OIL && HERE(URN) && game.prop[URN] != URN_EMPTY) {
+ else if (command.obj == OIL && HERE(URN) && game.objects[URN].prop != URN_EMPTY) {
command.obj = URN;
/* FALL THROUGH */;
- } else if (command.obj == PLANT && AT(PLANT2) && game.prop[PLANT2] != PLANT_THIRSTY) {
+ } else if (command.obj == PLANT && AT(PLANT2) && game.objects[PLANT2].prop != PLANT_THIRSTY) {
command.obj = PLANT2;
/* FALL THROUGH */;
} else if (command.obj == KNIFE && game.knfloc == game.loc) {
* 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) {
+ if (command.obj == NO_OBJECT || command.obj == INTRANSITIVE) {
/* Analyse an intransitive verb (ie, no object given yet). */
switch (command.verb) {
case CARRY:
projects / open-adventure.git / blobdiff