/* NetHack 3.6 hack.c $NHDT-Date: 1576638500 2019/12/18 03:08:20 $ $NHDT-Branch: NetHack-3.6 $:$NHDT-Revision: 1.220 $ */

/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */

/*-Copyright (c) Derek S. Ray, 2015. */

/* NetHack may be freely redistributed. See license for details. */

#include "hack.h"

/* #define DEBUG */ /* uncomment for debugging */

STATIC_DCL void NDECL(maybe_wail);

STATIC_DCL int NDECL(moverock);

STATIC_DCL int FDECL(still_chewing, (XCHAR_P, XCHAR_P));

STATIC_DCL void NDECL(dosinkfall);

STATIC_DCL boolean FDECL(findtravelpath, (int));

STATIC_DCL boolean FDECL(trapmove, (int, int, struct trap *));

STATIC_DCL struct monst *FDECL(monstinroom, (struct permonst *, int));

STATIC_DCL boolean FDECL(doorless_door, (int, int));

STATIC_DCL void FDECL(move_update, (BOOLEAN_P));

STATIC_DCL void FDECL(maybe_smudge_engr, (int, int, int, int));

STATIC_DCL void NDECL(domove_core);

#define IS_SHOP(x) (rooms[x].rtype >= SHOPBASE)

/* mode values for findtravelpath() */

#define TRAVP_TRAVEL 0

#define TRAVP_GUESS 1

#define TRAVP_VALID 2

static anything tmp_anything;

anything *

uint_to_any(ui)

unsigned ui;

{

tmp_anything = zeroany;

tmp_anything.a_uint = ui;

return &tmp_anything;

}

anything *

long_to_any(lng)

long lng;

{

tmp_anything = zeroany;

tmp_anything.a_long = lng;

return &tmp_anything;

}

anything *

monst_to_any(mtmp)

struct monst *mtmp;

{

tmp_anything = zeroany;

tmp_anything.a_monst = mtmp;

return &tmp_anything;

}

anything *

obj_to_any(obj)

struct obj *obj;

{

tmp_anything = zeroany;

tmp_anything.a_obj = obj;

return &tmp_anything;

}

boolean

revive_nasty(x, y, msg)

int x, y;

const char *msg;

{

register struct obj *otmp, *otmp2;

struct monst *mtmp;

coord cc;

boolean revived = FALSE;

for (otmp = level.objects[x][y]; otmp; otmp = otmp2) {

otmp2 = otmp->nexthere;

if (otmp->otyp == CORPSE

&& (is_rider(&mons[otmp->corpsenm])

|| otmp->corpsenm == PM_WIZARD_OF_YENDOR)) {

/* move any living monster already at that location */

if ((mtmp = m_at(x, y)) && enexto(&cc, x, y, mtmp->data))

rloc_to(mtmp, cc.x, cc.y);

if (msg)

Norep("%s", msg);

revived = revive_corpse(otmp);

}

}

/* this location might not be safe, if not, move revived monster */

if (revived) {

mtmp = m_at(x, y);

if (mtmp && !goodpos(x, y, mtmp, 0)

&& enexto(&cc, x, y, mtmp->data)) {

rloc_to(mtmp, cc.x, cc.y);

}

/* else impossible? */

}

return revived;

}

STATIC_OVL int

moverock()

{

register xchar rx, ry, sx, sy;

register struct obj *otmp;

register struct trap *ttmp;

register struct monst *mtmp;

sx = u.ux + u.dx, sy = u.uy + u.dy; /* boulder starting position */

while ((otmp = sobj_at(BOULDER, sx, sy)) != 0) {

/* make sure that this boulder is visible as the top object */

if (otmp != level.objects[sx][sy])

movobj(otmp, sx, sy);

rx = u.ux + 2 * u.dx; /* boulder destination position */

ry = u.uy + 2 * u.dy;

nomul(0);

if (Levitation || Is_airlevel(&u.uz)) {

if (Blind)

feel_location(sx, sy);

You("don't have enough leverage to push %s.", the(xname(otmp)));

/* Give them a chance to climb over it? */

return -1;

}

if (verysmall(youmonst.data) && !u.usteed) {

if (Blind)

feel_location(sx, sy);

pline("You're too small to push that %s.", xname(otmp));

goto cannot_push;

}

if (isok(rx, ry) && !IS_ROCK(levl[rx][ry].typ)

&& levl[rx][ry].typ != IRONBARS

&& (!IS_DOOR(levl[rx][ry].typ) || !(u.dx && u.dy)

|| doorless_door(rx, ry)) && !sobj_at(BOULDER, rx, ry)) {

ttmp = t_at(rx, ry);

mtmp = m_at(rx, ry);

/* KMH -- Sokoban doesn't let you push boulders diagonally */

if (Sokoban && u.dx && u.dy) {

if (Blind)

feel_location(sx, sy);

pline("%s won't roll diagonally on this %s.",

The(xname(otmp)), surface(sx, sy));

goto cannot_push;

}

if (revive_nasty(rx, ry, "You sense movement on the other side."))

return -1;

if (mtmp && !noncorporeal(mtmp->data)

&& (!mtmp->mtrapped

|| !(ttmp && is_pit(ttmp->ttyp)))) {

boolean deliver_part1 = FALSE;

if (Blind)

feel_location(sx, sy);

if (canspotmon(mtmp)) {

pline("There's %s on the other side.", a_monnam(mtmp));

deliver_part1 = TRUE;

} else {

You_hear("a monster behind %s.", the(xname(otmp)));

if (!Deaf)

deliver_part1 = TRUE;

map_invisible(rx, ry);

}

if (flags.verbose) {

char you_or_steed[BUFSZ];

Strcpy(you_or_steed,

u.usteed ? y_monnam(u.usteed) : "you");

pline("%s%s cannot move %s.",

deliver_part1

? "Perhaps that's why "

: "",

deliver_part1

? you_or_steed

: upstart(you_or_steed),

deliver_part1

? "it"

: the(xname(otmp)));

}

goto cannot_push;

}

if (ttmp) {

/* if a trap operates on the boulder, don't attempt

to move any others at this location; return -1

if another boulder is in hero's way, or 0 if he

should advance to the vacated boulder position */

switch (ttmp->ttyp) {

case LANDMINE:

if (rn2(10)) {

obj_extract_self(otmp);

place_object(otmp, rx, ry);

newsym(sx, sy);

pline("KAABLAMM!!! %s %s land mine.",

Tobjnam(otmp, "trigger"),

ttmp->madeby_u ? "your" : "a");

blow_up_landmine(ttmp);

/* if the boulder remains, it should fill the pit */

fill_pit(u.ux, u.uy);

if (cansee(rx, ry))

newsym(rx, ry);

return sobj_at(BOULDER, sx, sy) ? -1 : 0;

}

break;

case SPIKED_PIT:

case PIT:

obj_extract_self(otmp);

/* vision kludge to get messages right;

the pit will temporarily be seen even

if this is one among multiple boulders */

if (!Blind)

viz_array[ry][rx] |= IN_SIGHT;

if (!flooreffects(otmp, rx, ry, "fall")) {

place_object(otmp, rx, ry);

}

if (mtmp && !Blind)

newsym(rx, ry);

return sobj_at(BOULDER, sx, sy) ? -1 : 0;

case HOLE:

case TRAPDOOR:

if (Blind)

pline("Kerplunk! You no longer feel %s.",

the(xname(otmp)));

else

pline("%s%s and %s a %s in the %s!",

Tobjnam(otmp, (ttmp->ttyp == TRAPDOOR)

? "trigger"

: "fall"),

(ttmp->ttyp == TRAPDOOR) ? "" : " into",

otense(otmp, "plug"),

(ttmp->ttyp == TRAPDOOR) ? "trap door" : "hole",

surface(rx, ry));

deltrap(ttmp);

delobj(otmp);

bury_objs(rx, ry);

levl[rx][ry].wall_info &= ~W_NONDIGGABLE;

levl[rx][ry].candig = 1;

if (cansee(rx, ry))

newsym(rx, ry);

return sobj_at(BOULDER, sx, sy) ? -1 : 0;

case LEVEL_TELEP:

case TELEP_TRAP: {

int newlev = 0; /* lint suppression */

d_level dest;

if (ttmp->ttyp == LEVEL_TELEP) {

newlev = random_teleport_level();

if (newlev == depth(&u.uz) || In_endgame(&u.uz))

/* trap didn't work; skip "disappears" message */

goto dopush;

}

if (u.usteed)

pline("%s pushes %s and suddenly it disappears!",

upstart(y_monnam(u.usteed)), the(xname(otmp)));

else

You("push %s and suddenly it disappears!",

the(xname(otmp)));

if (ttmp->ttyp == TELEP_TRAP) {

(void) rloco(otmp);

} else {

obj_extract_self(otmp);

add_to_migration(otmp);

get_level(&dest, newlev);

otmp->ox = dest.dnum;

otmp->oy = dest.dlevel;

otmp->owornmask = (long) MIGR_RANDOM;

}

seetrap(ttmp);

return sobj_at(BOULDER, sx, sy) ? -1 : 0;

}

default:

break; /* boulder not affected by this trap */

}

}

if (closed_door(rx, ry))

goto nopushmsg;

if (boulder_hits_pool(otmp, rx, ry, TRUE))

continue;

/*

* Re-link at top of fobj chain so that pile order is preserved

* when level is restored.

*/

if (otmp != fobj) {

remove_object(otmp);

place_object(otmp, otmp->ox, otmp->oy);

}

{

#ifdef LINT /* static long lastmovetime; */

long lastmovetime;

lastmovetime = 0;

#else

/* note: reset to zero after save/restore cycle */

static NEARDATA long lastmovetime;

#endif

dopush:

if (!u.usteed) {

if (moves > lastmovetime + 2 || moves < lastmovetime)

pline("With %s effort you move %s.",

throws_rocks(youmonst.data) ? "little"

: "great",

the(xname(otmp)));

exercise(A_STR, TRUE);

} else

pline("%s moves %s.", upstart(y_monnam(u.usteed)),

the(xname(otmp)));

lastmovetime = moves;

}

/* Move the boulder *after* the message. */

if (glyph_is_invisible(levl[rx][ry].glyph))

unmap_object(rx, ry);

movobj(otmp, rx, ry); /* does newsym(rx,ry) */

if (Blind) {

feel_location(rx, ry);

feel_location(sx, sy);

} else {

newsym(sx, sy);

}

} else {

nopushmsg:

if (u.usteed)

pline("%s tries to move %s, but cannot.",

upstart(y_monnam(u.usteed)), the(xname(otmp)));

else

You("try to move %s, but in vain.", the(xname(otmp)));

if (Blind)

feel_location(sx, sy);

cannot_push:

if (throws_rocks(youmonst.data)) {

boolean

canpickup = (!Sokoban

/* similar exception as in can_lift():

when poly'd into a giant, you can

pick up a boulder if you have a free

slot or into the overflow ('#') slot

unless already carrying at least one */

&& (inv_cnt(FALSE) < 52 || !carrying(BOULDER))),

willpickup = (canpickup && autopick_testobj(otmp, TRUE));

if (u.usteed && P_SKILL(P_RIDING) < P_BASIC) {

You("aren't skilled enough to %s %s from %s.",

willpickup ? "pick up" : "push aside",

the(xname(otmp)), y_monnam(u.usteed));

} else {

/*

* willpickup: you easily pick it up

* canpickup: you could easily pick it up

* otherwise: you easily push it aside

*/

pline("However, you %seasily %s.",

(willpickup || !canpickup) ? "" : "could ",

(willpickup || canpickup) ? "pick it up"

: "push it aside");

sokoban_guilt();

break;

}

break;

}

if (!u.usteed

&& (((!invent || inv_weight() <= -850)

&& (!u.dx || !u.dy || (IS_ROCK(levl[u.ux][sy].typ)

&& IS_ROCK(levl[sx][u.uy].typ))))

|| verysmall(youmonst.data))) {

pline(

"However, you can squeeze yourself into a small opening.");

sokoban_guilt();

break;

} else

return -1;

}

}

return 0;

}

/*

* still_chewing()

*

* Chew on a wall, door, or boulder. [What about statues?]

* Returns TRUE if still eating, FALSE when done.

*/

STATIC_OVL int

still_chewing(x, y)

xchar x, y;

{

struct rm *lev = &levl[x][y];

struct obj *boulder = sobj_at(BOULDER, x, y);

const char *digtxt = (char *) 0, *dmgtxt = (char *) 0;

if (context.digging.down) /* not continuing previous dig (w/ pick-axe) */

(void) memset((genericptr_t) &context.digging, 0,

sizeof (struct dig_info));

if (!boulder

&& ((IS_ROCK(lev->typ) && !may_dig(x, y))

/* may_dig() checks W_NONDIGGABLE but doesn't handle iron bars */

|| (lev->typ == IRONBARS && (lev->wall_info & W_NONDIGGABLE)))) {

You("hurt your teeth on the %s.",

(lev->typ == IRONBARS)

? "bars"

: IS_TREE(lev->typ)

? "tree"

: "hard stone");

nomul(0);

return 1;

} else if (context.digging.pos.x != x || context.digging.pos.y != y

|| !on_level(&context.digging.level, &u.uz)) {

context.digging.down = FALSE;

context.digging.chew = TRUE;

context.digging.warned = FALSE;

context.digging.pos.x = x;

context.digging.pos.y = y;

assign_level(&context.digging.level, &u.uz);

/* solid rock takes more work & time to dig through */

context.digging.effort =

(IS_ROCK(lev->typ) && !IS_TREE(lev->typ) ? 30 : 60) + u.udaminc;

You("start chewing %s %s.",

(boulder || IS_TREE(lev->typ) || lev->typ == IRONBARS)

? "on a"

: "a hole in the",

boulder

? "boulder"

: IS_TREE(lev->typ)

? "tree"

: IS_ROCK(lev->typ)

? "rock"

: (lev->typ == IRONBARS)

? "bar"

: "door");

watch_dig((struct monst *) 0, x, y, FALSE);

return 1;

} else if ((context.digging.effort += (30 + u.udaminc)) <= 100) {

if (flags.verbose)

You("%s chewing on the %s.",

context.digging.chew ? "continue" : "begin",

boulder

? "boulder"

: IS_TREE(lev->typ)

? "tree"

: IS_ROCK(lev->typ)

? "rock"

: (lev->typ == IRONBARS)

? "bars"

: "door");

context.digging.chew = TRUE;

watch_dig((struct monst *) 0, x, y, FALSE);

return 1;

}

/* Okay, you've chewed through something */

u.uconduct.food++;

u.uhunger += rnd(20);

if (boulder) {

delobj(boulder); /* boulder goes bye-bye */

You("eat the boulder."); /* yum */

/*

* The location could still block because of

* 1. More than one boulder

* 2. Boulder stuck in a wall/stone/door.

*

* [perhaps use does_block() below (from vision.c)]

*/

if (IS_ROCK(lev->typ) || closed_door(x, y)

|| sobj_at(BOULDER, x, y)) {

block_point(x, y); /* delobj will unblock the point */

/* reset dig state */

(void) memset((genericptr_t) &context.digging, 0,

sizeof (struct dig_info));

return 1;

}

} else if (IS_WALL(lev->typ)) {

if (*in_rooms(x, y, SHOPBASE)) {

add_damage(x, y, SHOP_WALL_DMG);

dmgtxt = "damage";

}

digtxt = "chew a hole in the wall.";

if (level.flags.is_maze_lev) {

lev->typ = ROOM;

} else if (level.flags.is_cavernous_lev && !in_town(x, y)) {

lev->typ = CORR;

} else {

lev->typ = DOOR;

lev->doormask = D_NODOOR;

}

} else if (IS_TREE(lev->typ)) {

digtxt = "chew through the tree.";

lev->typ = ROOM;

} else if (lev->typ == IRONBARS) {

digtxt = "eat through the bars.";

dissolve_bars(x, y);

} else if (lev->typ == SDOOR) {

if (lev->doormask & D_TRAPPED) {

lev->doormask = D_NODOOR;

b_trapped("secret door", 0);

} else {

digtxt = "chew through the secret door.";

lev->doormask = D_BROKEN;

}

lev->typ = DOOR;

} else if (IS_DOOR(lev->typ)) {

if (*in_rooms(x, y, SHOPBASE)) {

add_damage(x, y, SHOP_DOOR_COST);

dmgtxt = "break";

}

if (lev->doormask & D_TRAPPED) {

lev->doormask = D_NODOOR;

b_trapped("door", 0);

} else {

digtxt = "chew through the door.";

lev->doormask = D_BROKEN;

}

} else { /* STONE or SCORR */

digtxt = "chew a passage through the rock.";

lev->typ = CORR;

}

unblock_point(x, y); /* vision */

newsym(x, y);

if (digtxt)

You1(digtxt); /* after newsym */

if (dmgtxt)

pay_for_damage(dmgtxt, FALSE);

(void) memset((genericptr_t) &context.digging, 0,

sizeof (struct dig_info));

return 0;

}

void

movobj(obj, ox, oy)

register struct obj *obj;

register xchar ox, oy;

{

/* optimize by leaving on the fobj chain? */

remove_object(obj);

newsym(obj->ox, obj->oy);

place_object(obj, ox, oy);

newsym(ox, oy);

}

static NEARDATA const char fell_on_sink[] = "fell onto a sink";

STATIC_OVL void

dosinkfall()

{

register struct obj *obj;

int dmg;

boolean lev_boots = (uarmf && uarmf->otyp == LEVITATION_BOOTS),

innate_lev = ((HLevitation & (FROMOUTSIDE | FROMFORM)) != 0L),

/* to handle being chained to buried iron ball, trying to

levitate but being blocked, then moving onto adjacent sink;

no need to worry about being blocked by terrain because we

couldn't be over a sink at the same time */

blockd_lev = (BLevitation == I_SPECIAL),

ufall = (!innate_lev && !blockd_lev

&& !(HFlying || EFlying)); /* BFlying */

if (!ufall) {

You((innate_lev || blockd_lev) ? "wobble unsteadily for a moment."

: "gain control of your flight.");

} else {

long save_ELev = ELevitation, save_HLev = HLevitation;

/* fake removal of levitation in advance so that final

disclosure will be right in case this turns out to

be fatal; fortunately the fact that rings and boots

are really still worn has no effect on bones data */

ELevitation = HLevitation = 0L;

You("crash to the floor!");

dmg = rn1(8, 25 - (int) ACURR(A_CON));

losehp(Maybe_Half_Phys(dmg), fell_on_sink, NO_KILLER_PREFIX);

exercise(A_DEX, FALSE);

selftouch("Falling, you");

for (obj = level.objects[u.ux][u.uy]; obj; obj = obj->nexthere)

if (obj->oclass == WEAPON_CLASS || is_weptool(obj)) {

You("fell on %s.", doname(obj));

losehp(Maybe_Half_Phys(rnd(3)), fell_on_sink,

NO_KILLER_PREFIX);

exercise(A_CON, FALSE);

}

ELevitation = save_ELev;

HLevitation = save_HLev;

}

/*

* Interrupt multi-turn putting on/taking off of armor (in which

* case we reached the sink due to being teleported while busy;

* in 3.4.3, Boots_on()/Boots_off() [called via (*afternmv)() when

* 'multi' reaches 0] triggered a crash if we were donning/doffing

* levitation boots [because the Boots_off() below causes 'uarmf'

* to be null by the time 'afternmv' gets called]).

*

* Interrupt donning/doffing if we fall onto the sink, or if the

* code below is going to remove levitation boots even when we

* haven't fallen (innate floating or flying becoming unblocked).

*/

if (ufall || lev_boots) {

(void) stop_donning(lev_boots ? uarmf : (struct obj *) 0);

/* recalculate in case uarmf just got set to null */

lev_boots = (uarmf && uarmf->otyp == LEVITATION_BOOTS);

}

/* remove worn levitation items */

ELevitation &= ~W_ARTI;

HLevitation &= ~(I_SPECIAL | TIMEOUT);

HLevitation++;

if (uleft && uleft->otyp == RIN_LEVITATION) {

obj = uleft;

Ring_off(obj);

off_msg(obj);

}

if (uright && uright->otyp == RIN_LEVITATION) {

obj = uright;

Ring_off(obj);

off_msg(obj);

}

if (lev_boots) {

obj = uarmf;

(void) Boots_off();

off_msg(obj);

}

HLevitation--;

/* probably moot; we're either still levitating or went

through float_down(), but make sure BFlying is up to date */

float_vs_flight();

}

/* intended to be called only on ROCKs or TREEs */

boolean

may_dig(x, y)

register xchar x, y;

{

struct rm *lev = &levl[x][y];

return (boolean) !((IS_STWALL(lev->typ) || IS_TREE(lev->typ))

&& (lev->wall_info & W_NONDIGGABLE));

}

boolean

may_passwall(x, y)

register xchar x, y;

{

return (boolean) !(IS_STWALL(levl[x][y].typ)

&& (levl[x][y].wall_info & W_NONPASSWALL));

}

boolean

bad_rock(mdat, x, y)

struct permonst *mdat;

register xchar x, y;

{

return (boolean) ((Sokoban && sobj_at(BOULDER, x, y))

|| (IS_ROCK(levl[x][y].typ)

&& (!tunnels(mdat) || needspick(mdat)

|| !may_dig(x, y))

&& !(passes_walls(mdat) && may_passwall(x, y))));

}

/* caller has already decided that it's a tight diagonal; check whether a

monster--who might be the hero--can fit through, and if not then return

the reason why: 1: can't fit, 2: possessions won't fit, 3: sokoban

returns 0 if we can squeeze through */

int

cant_squeeze_thru(mon)

struct monst *mon;

{

int amt;

struct permonst *ptr = mon->data;

/* too big? */

if (bigmonst(ptr)

&& !(amorphous(ptr) || is_whirly(ptr) || noncorporeal(ptr)

|| slithy(ptr) || can_fog(mon)))

return 1;

/* lugging too much junk? */

amt = (mon == &youmonst) ? inv_weight() + weight_cap()

: curr_mon_load(mon);

if (amt > 600)

return 2;

/* Sokoban restriction applies to hero only */

if (mon == &youmonst && Sokoban)

return 3;

/* can squeeze through */

return 0;

}

boolean

invocation_pos(x, y)

xchar x, y;

{

return (boolean) (Invocation_lev(&u.uz)

&& x == inv_pos.x && y == inv_pos.y);

}

/* return TRUE if (dx,dy) is an OK place to move

* mode is one of DO_MOVE, TEST_MOVE, TEST_TRAV, or TEST_TRAP

*/

boolean

test_move(ux, uy, dx, dy, mode)

int ux, uy, dx, dy;

int mode;

{

int x = ux + dx;

int y = uy + dy;

register struct rm *tmpr = &levl[x][y];

register struct rm *ust;

context.door_opened = FALSE;

/*

* Check for physical obstacles. First, the place we are going.

*/

if (IS_ROCK(tmpr->typ) || tmpr->typ == IRONBARS) {

if (Blind && mode == DO_MOVE)

feel_location(x, y);

if (Passes_walls && may_passwall(x, y)) {

; /* do nothing */

} else if (Underwater) {

/* note: if water_friction() changes direction due to

turbulence, new target destination will always be water,

so we won't get here, hence don't need to worry about

"there" being somewhere the player isn't sure of */

if (mode == DO_MOVE)

pline("There is an obstacle there.");

return FALSE;

} else if (tmpr->typ == IRONBARS) {

if ((dmgtype(youmonst.data, AD_RUST)

|| dmgtype(youmonst.data, AD_CORR)) && mode == DO_MOVE

&& still_chewing(x, y)) {

return FALSE;

}

if (!(Passes_walls || passes_bars(youmonst.data))) {

if (mode == DO_MOVE && iflags.mention_walls)

You("cannot pass through the bars.");

return FALSE;

}

} else if (tunnels(youmonst.data) && !needspick(youmonst.data)) {

/* Eat the rock. */

if (mode == DO_MOVE && still_chewing(x, y))

return FALSE;

} else if (flags.autodig && !context.run && !context.nopick && uwep

&& is_pick(uwep)) {

/* MRKR: Automatic digging when wielding the appropriate tool */

if (mode == DO_MOVE)

(void) use_pick_axe2(uwep);

return FALSE;

} else {

if (mode == DO_MOVE) {

if (is_db_wall(x, y))

pline("That drawbridge is up!");

/* sokoban restriction stays even after puzzle is solved */

else if (Passes_walls && !may_passwall(x, y)

&& In_sokoban(&u.uz))

pline_The("Sokoban walls resist your ability.");

else if (iflags.mention_walls)

pline("It's %s.",

(IS_WALL(tmpr->typ) || tmpr->typ == SDOOR) ? "a wall"

: IS_TREE(tmpr->typ) ? "a tree"

: "solid stone");

}

return FALSE;

}

} else if (IS_DOOR(tmpr->typ)) {

if (closed_door(x, y)) {

if (Blind && mode == DO_MOVE)

feel_location(x, y);

if (Passes_walls) {

; /* do nothing */

} else if (can_ooze(&youmonst)) {

if (mode == DO_MOVE)

You("ooze under the door.");

} else if (Underwater) {

if (mode == DO_MOVE)

pline("There is an obstacle there.");

return FALSE;

} else if (tunnels(youmonst.data) && !needspick(youmonst.data)) {

/* Eat the door. */

if (mode == DO_MOVE && still_chewing(x, y))

return FALSE;

} else {

if (mode == DO_MOVE) {

if (amorphous(youmonst.data))

You(

"try to ooze under the door, but can't squeeze your possessions through.");

if (flags.autoopen && !context.run && !Confusion

&& !Stunned && !Fumbling) {

context.door_opened = context.move =

doopen_indir(x, y);

} else if (x == ux || y == uy) {

if (Blind || Stunned || ACURR(A_DEX) < 10

|| Fumbling) {

if (u.usteed) {

You_cant("lead %s through that closed door.",

y_monnam(u.usteed));

} else {

pline("Ouch! You bump into a door.");

exercise(A_DEX, FALSE);

}

} else

pline("That door is closed.");

}

} else if (mode == TEST_TRAV || mode == TEST_TRAP)

goto testdiag;

return FALSE;

}

} else {

testdiag:

if (dx && dy && !Passes_walls

&& (!doorless_door(x, y) || block_door(x, y))) {

/* Diagonal moves into a door are not allowed. */

if (mode == DO_MOVE) {

if (Blind)

feel_location(x, y);

if (Underwater || iflags.mention_walls)

You_cant("move diagonally into an intact doorway.");

}

return FALSE;

}

}

}

if (dx && dy && bad_rock(youmonst.data, ux, y)

&& bad_rock(youmonst.data, x, uy)) {

/* Move at a diagonal. */

switch (cant_squeeze_thru(&youmonst)) {

case 3:

if (mode == DO_MOVE)

You("cannot pass that way.");

return FALSE;

case 2:

if (mode == DO_MOVE)

You("are carrying too much to get through.");

return FALSE;

case 1:

if (mode == DO_MOVE)

Your("body is too large to fit through.");

return FALSE;

default:

break; /* can squeeze through */

}

} else if (dx && dy && worm_cross(ux, uy, x, y)) {

/* consecutive long worm segments are at <ux,y> and <x,uy> */

if (mode == DO_MOVE)

pline("%s is in your way.", Monnam(m_at(ux, y)));

return FALSE;

}

/* Pick travel path that does not require crossing a trap.

* Avoid water and lava using the usual running rules.

* (but not u.ux/u.uy because findtravelpath walks toward u.ux/u.uy) */

if (context.run == 8 && (mode != DO_MOVE)

&& (x != u.ux || y != u.uy)) {

struct trap *t = t_at(x, y);

if ((t && t->tseen)

|| (!Levitation && !Flying && !is_clinger(youmonst.data)

&& is_pool_or_lava(x, y) && levl[x][y].seenv))

return (mode == TEST_TRAP);

}

if (mode == TEST_TRAP)

return FALSE; /* do not move through traps */

ust = &levl[ux][uy];

/* Now see if other things block our way . . */

if (dx && dy && !Passes_walls && IS_DOOR(ust->typ)

&& (!doorless_door(ux, uy) || block_entry(x, y))) {

/* Can't move at a diagonal out of a doorway with door. */

if (mode == DO_MOVE && iflags.mention_walls)

You_cant("move diagonally out of an intact doorway.");

return FALSE;

}

if (sobj_at(BOULDER, x, y) && (Sokoban || !Passes_walls)) {

if (!(Blind || Hallucination) && (context.run >= 2)

&& mode != TEST_TRAV) {

if (mode == DO_MOVE && iflags.mention_walls)

pline("A boulder blocks your path.");

return FALSE;

}

if (mode == DO_MOVE) {

/* tunneling monsters will chew before pushing */

if (tunnels(youmonst.data) && !needspick(youmonst.data)

&& !Sokoban) {

if (still_chewing(x, y))

return FALSE;

} else if (moverock() < 0)

return FALSE;

} else if (mode == TEST_TRAV) {

struct obj *obj;

/* never travel through boulders in Sokoban */

if (Sokoban)

return FALSE;

/* don't pick two boulders in a row, unless there's a way thru */

if (sobj_at(BOULDER, ux, uy) && !Sokoban) {

if (!Passes_walls

&& !(tunnels(youmonst.data) && !needspick(youmonst.data))

&& !carrying(PICK_AXE) && !carrying(DWARVISH_MATTOCK)

&& !((obj = carrying(WAN_DIGGING))

&& !objects[obj->otyp].oc_name_known))

return FALSE;

}

}

/* assume you'll be able to push it when you get there... */

}

/* OK, it is a legal place to move. */

return TRUE;

}

/*

* Find a path from the destination (u.tx,u.ty) back to (u.ux,u.uy).

* A shortest path is returned. If guess is TRUE, consider various

* inaccessible locations as valid intermediate path points.

* Returns TRUE if a path was found.

*/

STATIC_OVL boolean

findtravelpath(mode)

int mode;

{

/* if travel to adjacent, reachable location, use normal movement rules */

if ((mode == TRAVP_TRAVEL || mode == TRAVP_VALID) && context.travel1

&& distmin(u.ux, u.uy, u.tx, u.ty) == 1

&& !(u.ux != u.tx && u.uy != u.ty && NODIAG(u.umonnum))) {

context.run = 0;

if (test_move(u.ux, u.uy, u.tx - u.ux, u.ty - u.uy, TEST_MOVE)) {

if (mode == TRAVP_TRAVEL) {

u.dx = u.tx - u.ux;

u.dy = u.ty - u.uy;

nomul(0);

iflags.travelcc.x = iflags.travelcc.y = 0;

}

return TRUE;

}

if (mode == TRAVP_TRAVEL)

context.run = 8;

}

if (u.tx != u.ux || u.ty != u.uy) {

xchar travel[COLNO][ROWNO];

xchar travelstepx[2][COLNO * ROWNO];

xchar travelstepy[2][COLNO * ROWNO];

xchar tx, ty, ux, uy;

int n = 1; /* max offset in travelsteps */

int set = 0; /* two sets current and previous */

int radius = 1; /* search radius */

int i;

/* If guessing, first find an "obvious" goal location. The obvious

* goal is the position the player knows of, or might figure out

* (couldsee) that is closest to the target on a straight path.

*/

if (mode == TRAVP_GUESS || mode == TRAVP_VALID) {

tx = u.ux;

ty = u.uy;

ux = u.tx;

uy = u.ty;

} else {

tx = u.tx;

ty = u.ty;

ux = u.ux;

uy = u.uy;

}

noguess:

(void) memset((genericptr_t) travel, 0, sizeof travel);

travelstepx[0][0] = tx;

travelstepy[0][0] = ty;

while (n != 0) {

int nn = 0;

for (i = 0; i < n; i++) {

int dir;

int x = travelstepx[set][i];

int y = travelstepy[set][i];

static int ordered[] = { 0, 2, 4, 6, 1, 3, 5, 7 };

/* no diagonal movement for grid bugs */

int dirmax = NODIAG(u.umonnum) ? 4 : 8;

boolean alreadyrepeated = FALSE;

for (dir = 0; dir < dirmax; ++dir) {

int nx = x + xdir[ordered[dir]];

int ny = y + ydir[ordered[dir]];

/*

* When guessing and trying to travel as close as possible