/* NetHack 5.0 hack.c $NHDT-Date: 1781973050 2026/06/20 16:30:50 $ $NHDT-Branch: NetHack-5.0 $:$NHDT-Revision: 1.508 $ */

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

#include "extern.h"

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

staticfn boolean could_move_onto_boulder(coordxy, coordxy);

staticfn void dopush(coordxy, coordxy, coordxy, coordxy, struct obj *,

boolean);

staticfn void cannot_push_msg(struct obj *, coordxy, coordxy);

staticfn int cannot_push(struct obj *, coordxy, coordxy);

staticfn void rock_disappear_msg(struct obj *);

staticfn void moverock_done(coordxy, coordxy);

staticfn int moverock(void);

staticfn int moverock_core(coordxy, coordxy);

staticfn void dosinkfall(void);

staticfn boolean findtravelpath(int);

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

staticfn int QSORTCALLBACK notice_mons_cmp(const genericptr,

const genericptr) NONNULLPTRS;

staticfn schar u_simple_floortyp(coordxy, coordxy);

staticfn boolean swim_move_danger(coordxy, coordxy);

staticfn boolean domove_bump_mon(struct monst *, int) NONNULLARG1;

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

boolean *) NONNULLPTRS;

staticfn boolean domove_fight_ironbars(coordxy, coordxy);

staticfn boolean domove_fight_web(coordxy, coordxy);

staticfn boolean domove_swap_with_pet(struct monst *,

coordxy, coordxy) NONNULLARG1;

staticfn boolean domove_fight_empty(coordxy, coordxy);

staticfn boolean air_turbulence(void);

staticfn void slippery_ice_fumbling(void);

staticfn boolean impaired_movement(coordxy *, coordxy *) NONNULLPTRS;

staticfn boolean avoid_moving_on_trap(coordxy, coordxy, boolean);

staticfn boolean avoid_moving_on_liquid(coordxy, coordxy, boolean);

staticfn boolean avoid_running_into_trap_or_liquid(coordxy, coordxy);

staticfn boolean avoid_trap_andor_region(coordxy, coordxy);

staticfn boolean move_out_of_bounds(coordxy, coordxy);

staticfn boolean carrying_too_much(void);

staticfn boolean escape_from_sticky_mon(coordxy, coordxy);

staticfn void domove_core(void);

staticfn void maybe_smudge_engr(coordxy, coordxy, coordxy, coordxy);

staticfn struct monst *monstinroom(struct permonst *, int) NONNULLARG1;

staticfn boolean furniture_present(int, int);

staticfn void move_update(boolean);

staticfn int pickup_checks(void);

staticfn void maybe_wail(void);

staticfn boolean water_turbulence(coordxy *, coordxy *);

staticfn int QSORTCALLBACK cmp_weights(const void *, const void *);

#define IS_SHOP(x) (svr.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)

{

struct obj *otmp = 0, *otmp2 = 0;

struct monst *mtmp;

coord cc;

boolean revived = FALSE;

for (otmp = svl.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() <= (WT_SQUEEZABLE_INV * -1))

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

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

staticfn 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_OBSTRUCTED(levl[u.ux][sy].typ)

&& IS_OBSTRUCTED(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();

}

staticfn void

dopush(

coordxy sx,

coordxy sy,

coordxy rx,

coordxy ry,

struct obj *otmp,

boolean costly)

{

struct monst *shkp;

{

const char *what;

boolean givemesg, easypush;

/* 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 = svm.moves + 1L;

gb.bldrpush_oid = otmp->o_id;

}

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

|| svm.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.", YMonnam(u.usteed), what);

}

gb.bldrpushtime = svm.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;

normally otmp->unpaid would not apply because otmp isn't in

hero's inventory, but addtobill() sets it and subfrombill()

clears it */

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

/* pushing from inside shop to its boundary (or free spot) */

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

/* this can happen if hero pushes boulder from farther inside

shop into shop's free spot (which will add it to the bill),

then teleports or Passes_walls to doorway (without exiting

the shop), and then pushes the boulder from the free spot

back into the shop; it's contingent upon the shopkeeper not

"muttering an incantation" to fracture the boulder while it

is unpaid at the free spot */

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

}

}

staticfn void

cannot_push_msg(struct obj *otmp, coordxy sx, coordxy sy)

{

const char *what;

what = the(xname(otmp));

if (u.usteed)

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

YMonnam(u.usteed), what);

else

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

if (Blind)

feel_location(sx, sy);

}

staticfn int

cannot_push(struct obj *otmp, coordxy sx, coordxy sy)

{

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

|| !carrying(BOULDER))),

willpickup = (canpickup

&& (flags.pickup && !svc.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();

}

return 0;

}

if (could_move_onto_boulder(sx, sy)) {

pline(

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

sokoban_guilt();

return 0;

} else {

return -1;

}

}

staticfn void

rock_disappear_msg(struct obj *otmp)

{

if (u.usteed)

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

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

else

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

the(xname(otmp)));

}

staticfn void

moverock_done(coordxy sx, coordxy sy)

{

struct obj *otmp;

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

if (otmp->otyp == BOULDER)

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

}

staticfn int

moverock(void)

{

coordxy sx, sy;

int ret;

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

ret = moverock_core(sx, sy);

moverock_done(sx, sy);

return ret;

}

staticfn int

moverock_core(coordxy sx, coordxy sy)

{

coordxy rx, ry;

struct obj *otmp;

struct trap *ttmp;

struct monst *mtmp;

boolean costly, firstboulder = TRUE;

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

return -1;

}

/* 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 != svl.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 (svc.context.nopick) {

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

int res;

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)

svc.context.door_opened = svc.context.move = TRUE;

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

}

return res;

}

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

return -1;

}

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

if (Blind)

feel_location(sx, sy);

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

return cannot_push(otmp, sx, sy);

}

if (isok(rx, ry) && !IS_OBSTRUCTED(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));

return cannot_push(otmp, sx, sy);

}

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 {

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

}

return cannot_push(otmp, sx, sy);

}

if (closed_door(rx, ry)) {

cannot_push_msg(otmp, sx, sy);

return cannot_push(otmp, sx, sy);

}

/* at this point the boulder should be able to move (though

potentially into something like a trap, pool, or lava) */

/* rumbling disturbs buried zombies */

disturb_buried_zombies(sx, sy);

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

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)

gv.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:

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

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

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

dopush(sx, sy, rx, ry, otmp, costly);

continue;

}

FALLTHROUGH;

/*FALLTHRU*/

case TELEP_TRAP:

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

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

case ROLLING_BOULDER_TRAP:

{

int tox = rx;

int toy = ry;

/* the boulder continues until it reaches one of

the trap's launch spots or hits a wall / out-of-bounds */

while (isok(tox + u.dx, toy + u.dy)) {

tox += u.dx;

toy += u.dy;

if (tox == ttmp->launch.x && toy == ttmp->launch.y)

break;

if (tox == ttmp->launch2.x && toy == ttmp->launch2.y)

break;

}

pline("%s away from you!",

Tobjnam(otmp, "suddenly roll"));

feeltrap(ttmp);

launch_obj(BOULDER, sx, sy, tox, toy, ROLL | LAUNCH_KNOWN);

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

}

default:

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

}

}

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

}

dopush(sx, sy, rx, ry, otmp, costly);

} else {

cannot_push_msg(otmp, sx, sy);

return cannot_push(otmp, sx, sy);

}

}

return 0;

}

/*

* 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 (svc.context.digging.down) /* not continuing prev dig (w/ pick-axe) */

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

sizeof (struct dig_info));

if (!boulder

&& ((IS_OBSTRUCTED(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 (!svc.context.digging.chew

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

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

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

svc.context.digging.down = FALSE;

svc.context.digging.chew = TRUE;

svc.context.digging.warned = FALSE;

svc.context.digging.pos.x = x;

svc.context.digging.pos.y = y;

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

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

svc.context.digging.effort =

(IS_OBSTRUCTED(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_OBSTRUCTED(lev->typ)

? "rock"

: (lev->typ == IRONBARS)

? "bar"

: "door");

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

return 1;

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

if (flags.verbose)

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

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

boulder

? "boulder"

: IS_TREE(lev->typ)

? "tree"

: IS_OBSTRUCTED(lev->typ)

? "rock"

: (lev->typ == IRONBARS)

? "bars"

: "door");

svc.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_OBSTRUCTED(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_OBSTRUCTED(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) &svc.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 (svl.level.flags.is_maze_lev) {

lev->typ = ROOM;

} else if (svl.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;

}

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

newsym(x, y);

if (digtxt)

You1(digtxt); /* after newsym */

if (dmgtxt)

pay_for_damage(dmgtxt, FALSE);

(void) memset((genericptr_t) &svc.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);

}

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

{

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

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

}

boolean

bad_rock(struct permonst *mdat, coordxy x, coordxy y)

{

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

|| (IS_OBSTRUCTED(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 > WT_TOOMUCH_DIAGONAL)

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 == svi.inv_pos.x && y == svi.inv_pos.y);

}

/* return TRUE if (ux+dx,uy+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;

struct rm *ust;