/* NetHack 3.7 hack.c $NHDT-Date: 1695932717 2023/09/28 20:25:17 $ $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.410 $ */

/* 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 boolean could_move_onto_boulder(coordxy, coordxy);

static int moverock(void);

static void dosinkfall(void);

static boolean findtravelpath(int);

static boolean trapmove(coordxy, coordxy, struct trap *);

static void check_buried_zombies(coordxy, coordxy);

static schar u_simple_floortyp(coordxy, coordxy);

static boolean swim_move_danger(coordxy, coordxy);

static boolean domove_bump_mon(struct monst *, int);

static boolean domove_attackmon_at(struct monst *, coordxy, coordxy,

boolean *);

static boolean domove_fight_ironbars(coordxy, coordxy);

static boolean domove_fight_web(coordxy, coordxy);

static boolean domove_swap_with_pet(struct monst *, coordxy, coordxy);

static boolean domove_fight_empty(coordxy, coordxy);

static boolean air_turbulence(void);

static void slippery_ice_fumbling(void);

static boolean impaired_movement(coordxy *, coordxy *);

static boolean avoid_moving_on_trap(coordxy, coordxy, boolean);

static boolean avoid_moving_on_liquid(coordxy, coordxy, boolean);

static boolean avoid_running_into_trap_or_liquid(coordxy, coordxy);

static boolean move_out_of_bounds(coordxy, coordxy);

static boolean carrying_too_much(void);

static boolean escape_from_sticky_mon(coordxy, coordxy);

static void domove_core(void);

static void maybe_smudge_engr(coordxy, coordxy, coordxy, coordxy);

static struct monst *monstinroom(struct permonst *, int);

static boolean furniture_present(int, int);

static void move_update(boolean);

static int pickup_checks(void);

static boolean doorless_door(coordxy, coordxy);

static void maybe_wail(void);

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

/* XXX: if more sources of water walking than just boots are added,

cause_known(insight.c) should be externified and used for this */

#define Known_wwalking \

(uarmf && uarmf->otyp == WATER_WALKING_BOOTS \

&& objects[WATER_WALKING_BOOTS].oc_name_known \

&& !u.usteed)

#define Known_lwalking \

(Known_wwalking && Fire_resistance \

&& uarmf->oerodeproof && uarmf->rknown)

/* mode values for findtravelpath() */

#define TRAVP_TRAVEL 0

#define TRAVP_GUESS 1

#define TRAVP_VALID 2

anything *

uint_to_any(unsigned ui)

{

gt.tmp_anything = cg.zeroany;

gt.tmp_anything.a_uint = ui;

return &gt.tmp_anything;

}

anything *

long_to_any(long lng)

{

gt.tmp_anything = cg.zeroany;

gt.tmp_anything.a_long = lng;

return &gt.tmp_anything;

}

anything *

monst_to_any(struct monst *mtmp)

{

gt.tmp_anything = cg.zeroany;

gt.tmp_anything.a_monst = mtmp;

return &gt.tmp_anything;

}

anything *

obj_to_any(struct obj *obj)

{

gt.tmp_anything = cg.zeroany;

gt.tmp_anything.a_obj = obj;

return &gt.tmp_anything;

}

boolean

revive_nasty(coordxy x, coordxy y, const char *msg)

{

register struct obj *otmp, *otmp2;

struct monst *mtmp;

coord cc;

boolean revived = FALSE;

for (otmp = gl.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;

}

#define squeezeablylightinvent() (!gi.invent || inv_weight() <= -850)

/* can hero move onto a spot containing one or more boulders?

used for m<dir> and travel and during boulder push failure */

static boolean

could_move_onto_boulder(coordxy sx, coordxy sy)

{

/* can if able to phaze through rock (must be poly'd, so not riding) */

if (Passes_walls)

return TRUE;

/* can't when riding */

if (u.usteed)

return FALSE;

/* can if a giant, unless doing so allows hero to pass into a

diagonal squeeze at the same time */

if (throws_rocks(gy.youmonst.data))

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

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

/* can if tiny (implies carrying very little else couldn't move at all) */

if (verysmall(gy.youmonst.data))

return TRUE;

/* can squeeze to spot if carrying extremely little, otherwise can't */

return squeezeablylightinvent();

}

static int

moverock(void)

{

register coordxy rx, ry, sx, sy;

struct obj *otmp;

struct trap *ttmp;

struct monst *mtmp, *shkp;

const char *what;

boolean costly, firstboulder = TRUE;

int res = 0;

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

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

if (Blind && glyph_to_obj(glyph_at(sx, sy)) != BOULDER) {

pline("That feels like a boulder.");

map_object(otmp, TRUE);

nomul(0);

res = -1;

goto moverock_done;

}

/* when otmp->next_boulder is 1, xname() will format it as

"next boulder" instead of just "boulder"; affects

boulder_hits_pool()'s messages as well as messages below */

otmp->next_boulder = firstboulder ? 0 : 1;

/* FIXME? 'firstboulder' should be reset to True if this boulder

isn't the first and the previous one is named differently from

this one. Probably not worth bothering with... */

firstboulder = FALSE;

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

if (otmp != gl.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);

/* using m<dir> towards an adjacent boulder steps over/onto it if

poly'd into a giant or squeezes under/beside it if small/light

enough but is a no-op in other circumstances unless move attempt

reveals an unseen boulder or lack of remembered, unseen monster */

if (gc.context.nopick) {

int oldglyph = glyph_at(sx, sy); /* before feel_location() */

feel_location(sx, sy); /* same for all 3 if/else-if/else cases */

if (throws_rocks(gy.youmonst.data)) {

/* player has used 'm<dir>' to move, so step to boulder's

spot without pushing it; hero is poly'd into a giant,

so exotic forms of locomotion are out, but might be

levitating (ring, potion, spell) or flying (amulet) */

You("%s over a boulder here.", u_locomotion("step"));

/* ["over" seems weird on air level but what else to say?] */

sokoban_guilt();

res = 0; /* move to <sx,sy> */

} else if (could_move_onto_boulder(sx, sy)) {

You("squeeze yourself %s the boulder.",

Flying ? "over" : "against");

sokoban_guilt();

res = 0; /* move to <sx,sy> */

} else {

There("is a boulder in your way.");

/* use a move if hero learns something; see test_move() for

how/why 'context.door_opened' is being dragged into this */

if (glyph_at(sx, sy) != oldglyph)

gc.context.door_opened = gc.context.move = TRUE;

res = -1; /* don't move to <sx,sy>, so no soko guilt */

}

goto moverock_done; /* stop further push attempts */

}

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

/* FIXME? behavior in an air bubble on the water level should

be similar to being on the air level; both cases probably

ought to let push attempt proceed when flying (which implies

not levitating) */

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? */

res = -1;

goto moverock_done;

}

if (verysmall(gy.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);

costly = (costly_spot(sx, sy)

&& shop_keeper(*in_rooms(sx, sy, SHOPBASE)));

/* 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.")) {

res = -1;

goto moverock_done;

}

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 {

Soundeffect(se_monster_behind_boulder, 50);

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

if (!Deaf)

deliver_part1 = TRUE;

map_invisible(rx, ry);

}

if (Verbose(1, moverock)) {

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) {

int newlev = 0; /* lint suppression */

d_level dest;

/* 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("%s! %s %s land mine.",

/* "kablam" is a variation of "ka-boom" or

"kablooey", rather cartoonish descriptions

of the sound of an explosion, but give it

even when deaf if hero sees the explosion */

(!Deaf || !Blind) ? "KAABLAMM!!"

/* use an alternate exclamation when feeling

the floor/ground/whatever shake (or maybe

a weak shockwave if levitating or flying) */

: "Gadzooks",

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);

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

goto moverock_done;

}

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)

gv.viz_array[ry][rx] |= IN_SIGHT;

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

place_object(otmp, rx, ry);

}

if (mtmp && !Blind)

newsym(rx, ry);

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

goto moverock_done;

case HOLE:

case TRAPDOOR:

Soundeffect(se_kerplunk_boulder_gone, 40);

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);

useupf(otmp, 1L);

bury_objs(rx, ry);

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

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

if (cansee(rx, ry))

newsym(rx, ry);

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

goto moverock_done;

case LEVEL_TELEP:

/* 20% chance of picking current level; 100% chance for

that if in single-level branch (Knox) or in endgame */

newlev = random_teleport_level();

/* if trap doesn't work, skip "disappears" message */

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

goto dopush;

/*FALLTHRU*/

case TELEP_TRAP:

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)));

otmp->next_boulder = 0; /* reset before moving it */

if (ttmp->ttyp == TELEP_TRAP) {

(void) rloco(otmp);

} else {

if (costly)

stolen_value(otmp, rx, ry, !ttmp->tseen, FALSE);

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);

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

goto moverock_done;

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);

}

{

boolean givemesg, easypush;

dopush:

/* give boulder pushing feedback if this is a different

boulder than the last one pushed or if it's been at

least 2 turns since we last pushed this boulder;

unlike with Norep(), intervening messages don't cause

it to repeat, only doing something else in the meantime */

if (otmp->o_id != gb.bldrpush_oid) {

gb.bldrpushtime = gm.moves + 1L;

gb.bldrpush_oid = otmp->o_id;

}

givemesg = (gm.moves > gb.bldrpushtime + 2L

|| gm.moves < gb.bldrpushtime);

what = givemesg ? the(xname(otmp)) : 0;

if (!u.usteed) {

easypush = throws_rocks(gy.youmonst.data);

if (givemesg)

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

easypush ? "little" : "great", what);

if (!easypush)

exercise(A_STR, TRUE);

} else {

if (givemesg)

pline("%s moves %s.",

upstart(y_monnam(u.usteed)), what);

}

gb.bldrpushtime = gm.moves;

}

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

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

unmap_object(rx, ry);

otmp->next_boulder = 0;

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

if (Blind) {

feel_location(rx, ry);

feel_location(sx, sy);

} else {

newsym(sx, sy);

}

/* maybe adjust bill if boulder was pushed across shop boundary */

if (costly && !costly_spot(rx, ry)) {

addtobill(otmp, FALSE, FALSE, FALSE);

} else if (!costly && costly_spot(rx, ry) && otmp->unpaid

&& ((shkp = shop_keeper(*in_rooms(rx, ry, SHOPBASE)))

!= 0)

&& onshopbill(otmp, shkp, TRUE)) {

subfrombill(otmp, shkp);

} else if (otmp->unpaid

&& (shkp = find_objowner(otmp, sx, sy)) != 0

&& !strchr(in_rooms(rx, ry, SHOPBASE),

ESHK(shkp)->shoproom)) {

/* once the boulder is fully out of the shop, so that it's

* impossible to change your mind and push it back in without

* leaving and triggering Kops, switch it to stolen_value */

stolen_value(otmp, sx, sy, TRUE, FALSE);

}

} else {

nopushmsg:

what = the(xname(otmp));

if (u.usteed)

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

upstart(y_monnam(u.usteed)), what);

else

You("try to move %s, but in vain.", what);

if (Blind)

feel_location(sx, sy);

cannot_push:

if (throws_rocks(gy.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

&& (flags.pickup && !gc.context.nopick)

&& 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 {

/*

* will pick up: you easily pick it up

* can but won't: you maneuver over it and could pick it up

* can't pick up: you maneuver over it (possibly followed

* by feedback from failed auto-pickup attempt)

*/

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

willpickup ? "easily pick it up"

: "maneuver over it",

(canpickup && !willpickup)

? " and could pick it up"

: "");

/* similar to dropping everything and squeezing onto

a Sokoban boulder's spot, moving to same breaks the

Sokoban rules because on next step you could go

past it without pushing it to plug a pit or hole */

sokoban_guilt();

break;

}

break;

}

if (could_move_onto_boulder(sx, sy)) {

pline(

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

sokoban_guilt();

break;

} else {

res = -1;

goto moverock_done;

}

}

}

res = 0;

moverock_done:

for (otmp = gl.level.objects[sx][sy]; otmp; otmp = otmp->nexthere)

if (otmp->otyp == BOULDER)

otmp->next_boulder = 0; /* resume normal xname() for this obj */

return res;

}

/*

* still_chewing()

*

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

* Returns TRUE if still eating, FALSE when done.

*/

int

still_chewing(coordxy x, coordxy y)

{

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

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

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

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

(void) memset((genericptr_t) &gc.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 (lev->typ == IRONBARS

&& metallivorous(gy.youmonst.data) && u.uhunger > 1500) {

/* finishing eating via 'morehungry()' doesn't handle choking */

You("are too full to eat the bars.");

nomul(0);

return 1;

} else if (!gc.context.digging.chew

|| gc.context.digging.pos.x != x

|| gc.context.digging.pos.y != y

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

gc.context.digging.down = FALSE;

gc.context.digging.chew = TRUE;

gc.context.digging.warned = FALSE;

gc.context.digging.pos.x = x;

gc.context.digging.pos.y = y;

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

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

gc.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 ((gc.context.digging.effort += (30 + u.udaminc)) <= 100) {

if (Verbose(1, still_chewing))

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

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

boulder

? "boulder"

: IS_TREE(lev->typ)

? "tree"

: IS_ROCK(lev->typ)

? "rock"

: (lev->typ == IRONBARS)

? "bars"

: "door");

gc.context.digging.chew = TRUE;

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

return 1;

}

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

if (!u.uconduct.food++)

livelog_printf(LL_CONDUCT,

"ate for the first time, by chewing through %s",

boulder ? "a boulder"

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

: IS_ROCK(lev->typ) ? "rock"

: (lev->typ == IRONBARS) ? "iron bars"

: "a door");

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) &gc.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 (gl.level.flags.is_maze_lev) {

lev->typ = ROOM;

} else if (gl.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) {

if (metallivorous(gy.youmonst.data)) { /* should always be True here */

/* arbitrary amount; unlike proper eating, nutrition is

bestowed in a lump sum at the end */

int nut = (int) objects[HEAVY_IRON_BALL].oc_weight;

/* lesshungry() requires that victual be set up, so skip it;

morehungry() of a negative amount will increase nutrition

without any possibility of choking to death on the meal;

updates hunger state and requests status update if changed */

morehungry(-nut);

}

digtxt = u_at(x, y)

? "devour the iron bars."

: "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", NO_PART);

} 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", NO_PART);

} 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) &gc.context.digging, 0,

sizeof (struct dig_info));

return 0;

}

void

movobj(struct obj *obj, coordxy ox, coordxy oy)

{

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

remove_object(obj);

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

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

place_object(obj, ox, oy);

newsym(ox, oy);

}

static void

dosinkfall(void)

{

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

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 = gl.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(register coordxy x, register coordxy 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(register coordxy x, register coordxy y)

{

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

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

}

boolean

bad_rock(struct permonst *mdat, register coordxy x, register coordxy 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(struct monst *mon)

{

int amt;

struct permonst *ptr = mon->data;

if ((mon == &gy.youmonst) ? Passes_walls : passes_walls(ptr))

return 0;

/* 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 == &gy.youmonst) ? inv_weight() + weight_cap()

: curr_mon_load(mon);

if (amt > 600)

return 2;

/* Sokoban restriction applies to hero only */

if (mon == &gy.youmonst && Sokoban)

return 3;

/* can squeeze through */

return 0;

}

boolean

invocation_pos(coordxy x, coordxy y)

{

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

&& x == gi.inv_pos.x && y == gi.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(

coordxy ux, coordxy uy,

coordxy dx, coordxy dy, /* these are -1|0|+1, not coordinates */

int mode)

{

coordxy x = ux + dx;

coordxy y = uy + dy;

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

struct rm *ust;

gc.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)

There("is an obstacle there.");

return FALSE;

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

if (mode == DO_MOVE

&& (dmgtype(gy.youmonst.data, AD_RUST)

|| dmgtype(gy.youmonst.data, AD_CORR)

|| metallivorous(gy.youmonst.data))

&& still_chewing(x, y)) {

return FALSE;

}

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

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

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

return FALSE;

}

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

/* Eat the rock. */

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

return FALSE;

} else if (flags.autodig && !gc.context.run && !gc.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 (flags.mention_walls) {

char buf[BUFSZ];

coord cc;

int sym = 0;

const char *firstmatch = 0;

cc.x = x, cc.y = y;

do_screen_description(cc, TRUE, sym, buf, &firstmatch,

NULL);

if (!strcmp(firstmatch, "stone"))

Sprintf(buf, "solid stone");

else

Sprintf(buf, "%s", an(firstmatch));

pline("It's %s.", buf);

}

}

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(&gy.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(gy.youmonst.data)

&& !needspick(gy.youmonst.data)) {

/* Eat the door. */

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

return FALSE;

} else {

if (mode == DO_MOVE) {

if (amorphous(gy.youmonst.data))

You(

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

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

&& !Confusion && !Stunned && !Fumbling) {