/* NetHack 3.7 hack.c $NHDT-Date: 1736530208 2025/01/10 09:30:08 $ $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.477 $ */

/* 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, *otmp2;

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;

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

svc.context.door_opened = FALSE;

if (!isok(x, y))

return FALSE;

tmpr = &levl[x][y];

/*

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

*/

if (IS_OBSTRUCTED(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 */