/* NetHack 5.0 dig.c $NHDT-Date: 1781973044 2026/06/20 16:30:44 $ $NHDT-Branch: NetHack-5.0 $:$NHDT-Revision: 1.236 $ */

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

/*-Copyright (c) Michael Allison, 2012. */

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

#include "hack.h"

staticfn boolean rm_waslit(void);

staticfn void mkcavepos(coordxy, coordxy, int, boolean, boolean);

staticfn void mkcavearea(boolean);

staticfn boolean pick_can_reach(struct obj *, coordxy, coordxy) NONNULLARG1;

staticfn int dig(void);

staticfn void dig_up_grave(coord *);

staticfn boolean watchman_canseeu(struct monst *) NONNULLARG1;

staticfn int adj_pit_checks(coord *, char *) NONNULLARG2;

staticfn void pit_flow(struct trap *, schar);

staticfn boolean furniture_handled(coordxy, coordxy, boolean);

/* Indices returned by dig_typ() */

enum dig_types {

DIGTYP_UNDIGGABLE = 0,

DIGTYP_ROCK,

DIGTYP_STATUE,

DIGTYP_BOULDER,

DIGTYP_DOOR,

DIGTYP_TREE

};

staticfn boolean

rm_waslit(void)

{

coordxy x, y;

if (levl[u.ux][u.uy].typ == ROOM && levl[u.ux][u.uy].waslit)

return TRUE;

for (x = u.ux - 2; x < u.ux + 3; x++)

for (y = u.uy - 1; y < u.uy + 2; y++)

if (isok(x, y) && levl[x][y].waslit)

return TRUE;

return FALSE;

}

/* Change level topology. Messes with vision tables and ignores things like

* boulders in the name of a nice effect. Vision will get fixed up again

* immediately after the effect is complete.

*/

staticfn void

mkcavepos(coordxy x, coordxy y, int dist, boolean waslit, boolean rockit)

{

struct rm *lev;

if (!isok(x, y))

return;

lev = &levl[x][y];

if (rockit) {

struct monst *mtmp;

if (IS_OBSTRUCTED(lev->typ))

return;

if (t_at(x, y))

return; /* don't cover the portal */

if ((mtmp = m_at(x, y)) != 0) /* make sure crucial monsters survive */

if (!passes_walls(mtmp->data))

(void) rloc(mtmp, RLOC_NOMSG);

} else if (lev->typ == ROOM)

return;

unblock_point(x, y); /* make sure vision knows this location is open */

/* fake out saved state */

lev->seenv = 0;

lev->doormask = 0;

if (dist < 3)

lev->lit = (rockit ? FALSE : TRUE);

if (waslit)

lev->waslit = (rockit ? FALSE : TRUE);

lev->horizontal = FALSE;

/* short-circuit vision recalc */

gv.viz_array[y][x] = (dist < 3) ? (IN_SIGHT | COULD_SEE) : COULD_SEE;

lev->typ = (rockit ? STONE : ROOM); /* flags set via doormask above */

if (dist >= 3)

impossible("mkcavepos called with dist %d", dist);

feel_newsym(x, y);

}

staticfn void

mkcavearea(boolean rockit)

{

int dist;

coordxy xmin = u.ux, xmax = u.ux;

coordxy ymin = u.uy, ymax = u.uy;

coordxy i;

boolean waslit = rm_waslit();

if (rockit) {

Soundeffect(se_crashing_rock, 100);

pline("Crash! The ceiling collapses around you!");

} else {

pline("A mysterious force %s cave around you!",

(levl[u.ux][u.uy].typ == CORR) ? "creates a" : "extends the");

}

display_nhwindow(WIN_MESSAGE, TRUE);

for (dist = 1; dist <= 2; dist++) {

xmin--;

xmax++;

/* top and bottom */

if (dist < 2) { /* the area is wider that it is high */

ymin--;

ymax++;

for (i = xmin + 1; i < xmax; i++) {

mkcavepos(i, ymin, dist, waslit, rockit);

mkcavepos(i, ymax, dist, waslit, rockit);

}

}

/* left and right */

for (i = ymin; i <= ymax; i++) {

mkcavepos(xmin, i, dist, waslit, rockit);

mkcavepos(xmax, i, dist, waslit, rockit);

}

flush_screen(1); /* make sure the new glyphs shows up */

nh_delay_output();

}

if (!rockit && levl[u.ux][u.uy].typ == CORR) {

levl[u.ux][u.uy].typ = ROOM; /* flags for CORR already 0 */

if (waslit)

levl[u.ux][u.uy].waslit = TRUE;

newsym(u.ux, u.uy); /* in case player is invisible */

}

gv.vision_full_recalc = 1; /* everything changed */

}

/* called when attempting to break a statue or boulder with a pick */

staticfn boolean

pick_can_reach(struct obj *pick, coordxy x, coordxy y)

{

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

/* tseen: pit only affects item positioning when it is known */

boolean target_in_pit = t && is_pit(t->ttyp) && t->tseen;

/* if hero is in a pit, pick can only reach if the statue is too and

the two pits are conjoined or the statue isn't and pick is two-handed;

this applies to hero in pit trying to reach an adjcacent boulder too */

if (u.utrap && u.utraptype == TT_PIT) {

if (target_in_pit)

return conjoined_pits(t, t_at(u.ux, u.uy), FALSE);

return bimanual(pick);

}

/* when hero isn't in a pit, a mattock or flying hero w/ pick can reach

whether or not the statue is in a pit */

if (bimanual(pick) || Flying)

return TRUE;

/* one-handed pick-axe can reach if statue isn't in a pit */

if (!target_in_pit)

return TRUE;

return FALSE;

}

/* When digging into location <x,y>, what are you actually digging into? */

int

dig_typ(struct obj *otmp, coordxy x, coordxy y)

{

int ltyp;

if (!isok(x, y) || !otmp || (!is_pick(otmp) && !is_axe(otmp)))

return DIGTYP_UNDIGGABLE;

ltyp = levl[x][y].typ;

if (is_axe(otmp))

return closed_door(x, y) ? DIGTYP_DOOR

: IS_TREE(ltyp) ? DIGTYP_TREE /* axe vs tree */

: DIGTYP_UNDIGGABLE;

/*assert(is_pick(otmp));*/

return (sobj_at(STATUE, x, y) && pick_can_reach(otmp, x, y))

? DIGTYP_STATUE

: (sobj_at(BOULDER, x, y) && pick_can_reach(otmp, x, y))

? DIGTYP_BOULDER

: closed_door(x, y) ? DIGTYP_DOOR

: IS_TREE(ltyp) ? DIGTYP_UNDIGGABLE /* pick vs tree */

: (IS_OBSTRUCTED(ltyp)

&& (!svl.level.flags.arboreal || IS_WALL(ltyp)))

? DIGTYP_ROCK

: DIGTYP_UNDIGGABLE;

}

boolean

is_digging(void)

{

if (go.occupation == dig) {

return TRUE;

}

return FALSE;

}

#define BY_YOU (&gy.youmonst)

#define BY_OBJECT ((struct monst *) 0)

enum digcheck_result

dig_check(struct monst *madeby, coordxy x, coordxy y)

{

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

if (On_stairs(x, y)) {

stairway *stway = stairway_at(x, y);

if (stway->isladder) {

return DIGCHECK_FAIL_ONLADDER;

} else {

return DIGCHECK_FAIL_ONSTAIRS;

}

} else if (IS_THRONE(levl[x][y].typ) && madeby != BY_OBJECT) {

return DIGCHECK_FAIL_THRONE;

} else if (IS_ALTAR(levl[x][y].typ)

&& (madeby != BY_OBJECT

|| (altarmask_at(x, y) & AM_SANCTUM) != 0)) {

return DIGCHECK_FAIL_ALTAR;

} else if (Is_airlevel(&u.uz)) {

return DIGCHECK_FAIL_AIRLEVEL;

} else if (Is_waterlevel(&u.uz)) {

return DIGCHECK_FAIL_WATERLEVEL;

} else if ((IS_OBSTRUCTED(levl[x][y].typ) && levl[x][y].typ != SDOOR

&& (levl[x][y].wall_info & W_NONDIGGABLE) != 0)) {

return DIGCHECK_FAIL_TOOHARD;

} else if (ttmp && undestroyable_trap(ttmp->ttyp)) {

return DIGCHECK_FAIL_UNDESTROYABLETRAP;

} else if (!Can_dig_down(&u.uz) && !levl[x][y].candig) {

if (ttmp) {

if (!is_hole(ttmp->ttyp) && !is_pit(ttmp->ttyp))

return DIGCHECK_PASSED_DESTROY_TRAP;

else

return DIGCHECK_FAIL_CANTDIG;

} else {

return DIGCHECK_PASSED_PITONLY;

}

} else if (sobj_at(BOULDER, x, y)) {

return DIGCHECK_FAIL_BOULDER;

} else if (madeby == BY_OBJECT

/* the block against existing traps is mainly to

prevent broken wands from turning holes into pits */

&& (ttmp || is_pool_or_lava(x, y))) {

/* digging by player handles pools separately */

return DIGCHECK_FAIL_OBJ_POOL_OR_TRAP;

}

return DIGCHECK_PASSED;

}

void

digcheck_fail_message(enum digcheck_result digresult, struct monst *madeby,

coordxy x, coordxy y)

{

const char *verb =

(madeby == BY_YOU && uwep && is_axe(uwep)) ? "chop" : "dig in";

if (digresult < DIGCHECK_FAILED)

return;

switch (digresult) {

case DIGCHECK_FAIL_AIRLEVEL:

You("cannot %s thin air.", verb);

break;

case DIGCHECK_FAIL_ALTAR:

pline_The("altar is too hard to break apart.");

break;

case DIGCHECK_FAIL_BOULDER:

There("isn't enough room to %s here.", verb);

break;

case DIGCHECK_FAIL_ONLADDER:

pline_The("ladder resists your effort.");

break;

case DIGCHECK_FAIL_ONSTAIRS:

pline_The("stairs are too hard to %s.", verb);

break;

case DIGCHECK_FAIL_THRONE:

pline_The("throne is too hard to break apart.");

break;

case DIGCHECK_FAIL_CANTDIG:

case DIGCHECK_FAIL_TOOHARD:

case DIGCHECK_FAIL_UNDESTROYABLETRAP:

pline_The("%s here is too hard to %s.", surface(x, y), verb);

break;

case DIGCHECK_FAIL_WATERLEVEL:

pline_The("%s splashes and subsides.", hliquid("water"));

break;

case DIGCHECK_FAIL_OBJ_POOL_OR_TRAP:

case DIGCHECK_PASSED:

case DIGCHECK_PASSED_PITONLY:

case DIGCHECK_PASSED_DESTROY_TRAP:

break;

}

}

staticfn int

dig(void)

{

struct rm *lev;

coordxy dpx = svc.context.digging.pos.x, dpy = svc.context.digging.pos.y;

boolean ispick = uwep && is_pick(uwep);

const char *verb = (!uwep || is_pick(uwep)) ? "dig into" : "chop through";

enum digcheck_result dcresult = DIGCHECK_PASSED;

lev = &levl[dpx][dpy];

/* perhaps a nymph stole your pick-axe while you were busy digging */

/* or perhaps you teleported away */

if (u.uswallow || !uwep || (!ispick && !is_axe(uwep))

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

|| ((svc.context.digging.down ? (dpx != u.ux || dpy != u.uy)

: !next2u(dpx, dpy))))

return 0;

if (svc.context.digging.down) {

dcresult = dig_check(BY_YOU, u.ux, u.uy);

if (dcresult >= DIGCHECK_FAILED) {

digcheck_fail_message(dcresult, BY_YOU, u.ux, u.uy);

return 0;

}

} else { /* !svc.context.digging.down */

if (IS_TREE(lev->typ) && !may_dig(dpx, dpy)

&& dig_typ(uwep, dpx, dpy) == DIGTYP_TREE) {

pline("This tree seems to be petrified.");

return 0;

}

if (IS_OBSTRUCTED(lev->typ) && !may_dig(dpx, dpy)

&& dig_typ(uwep, dpx, dpy) == DIGTYP_ROCK) {

pline("This %s is too hard to %s.",

is_db_wall(dpx, dpy) ? "drawbridge" : "wall", verb);

return 0;

}

}

if (Fumbling && !rn2(3)) {

switch (rn2(3)) {

case 0:

if (!welded(uwep)) {

You("fumble and drop %s.", yname(uwep));

dropx(uwep);

} else {

if (u.usteed)

pline("%s and %s %s!", Yobjnam2(uwep, "bounce"),

otense(uwep, "hit"), mon_nam(u.usteed));

else

pline("Ouch! %s and %s you!", Yobjnam2(uwep, "bounce"),

otense(uwep, "hit"));

set_wounded_legs(RIGHT_SIDE, 5 + rnd(5));

}

break;

case 1:

Soundeffect(se_bang_weapon_side, 100);

pline("Bang! You hit with the broad side of %s!",

the(xname(uwep)));

wake_nearby(FALSE);

break;

default:

Your("swing misses its mark.");

break;

}

return 0;

}

svc.context.digging.effort +=

10 + rn2(5) + abon() + uwep->spe - greatest_erosion(uwep) + u.udaminc;

if (Race_if(PM_DWARF))

svc.context.digging.effort *= 2;

if (svc.context.digging.down) {

struct trap *ttmp = t_at(dpx, dpy);

if (svc.context.digging.effort > 250

|| (ttmp && ttmp->ttyp == HOLE)) {

(void) dighole(FALSE, FALSE, (coord *) 0);

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

sizeof svc.context.digging);

return 0; /* done with digging */

}

if (svc.context.digging.effort <= 50

|| (ttmp && (ttmp->ttyp == TRAPDOOR || is_pit(ttmp->ttyp)))) {

return 1;

} else if (ttmp && (ttmp->ttyp == LANDMINE

|| (ttmp->ttyp == BEAR_TRAP && !u.utrap))) {

/* digging onto a set object trap triggers it;

hero should have used #untrap first */

dotrap(ttmp, FORCETRAP);

/* restart completely from scratch if we resume digging */

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

sizeof svc.context.digging);

return 0;

} else if (ttmp && ttmp->ttyp == BEAR_TRAP && u.utrap) {

if (rnl(7) > (Fumbling ? 1 : 4)) {

char kbuf[BUFSZ];

int dmg = dmgval(uwep, &gy.youmonst) + dbon();

if (dmg < 1)

dmg = 1;

else if (uarmf)

dmg = (dmg + 1) / 2;

You("hit yourself in the %s.", body_part(FOOT));

Sprintf(kbuf, "chopping off %s own %s", uhis(),

body_part(FOOT));

losehp(Maybe_Half_Phys(dmg), kbuf, KILLED_BY);

} else {

You("destroy the bear trap with %s.",

yobjnam(uwep, (const char *) 0));

deltrap(ttmp);

reset_utrap(TRUE); /* release from trap, maybe Lev or Fly */

}

/* we haven't made any progress toward a pit yet */

svc.context.digging.effort = 0;

return 0;

} else if (ttmp && dcresult == DIGCHECK_PASSED_DESTROY_TRAP) {

const char *ttmpname = trapname(ttmp->ttyp, FALSE);

if (ispick)

You("destroy %s with %s.",

ttmp->tseen ? the(ttmpname) : an(ttmpname),

yobjnam(uwep, (const char *) 0));

deltrap(ttmp);

/* we haven't made any progress toward a pit yet */

svc.context.digging.effort = 0;

return 0;

}

if (IS_ALTAR(lev->typ)) {

altar_wrath(dpx, dpy);

angry_priest();

}

/* make pit at <u.ux,u.uy> */

if (dighole(TRUE, FALSE, (coord *) 0)) {

svc.context.digging.level.dnum = 0;

svc.context.digging.level.dlevel = -1;

}

return 0;

}

if (svc.context.digging.effort > 100) {

char digbuf[BUFSZ];

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

struct obj *obj, *bobj;

boolean shopedge = *in_rooms(dpx, dpy, SHOPBASE);

int digtyp = dig_typ(uwep, dpx, dpy);

if (digtyp == DIGTYP_STATUE

&& (obj = sobj_at(STATUE, dpx, dpy)) != 0) {

if (break_statue(obj))

digtxt = "The statue shatters.";

else

/* it was a statue trap; break_statue()

printed a message and updated the screen */

digtxt = (char *) 0;

} else if (digtyp == DIGTYP_BOULDER

&& (obj = sobj_at(BOULDER, dpx, dpy)) != 0) {

fracture_rock(obj);

/*[5.0: this probably isn't necessary anymore]*/

if ((bobj = sobj_at(BOULDER, dpx, dpy)) != 0) {

/* another boulder here, restack it to the top */

obj_extract_self(bobj);

place_object(bobj, dpx, dpy);

}

digtxt = "The boulder falls apart.";

} else if (lev->typ == STONE || lev->typ == SCORR

|| IS_TREE(lev->typ)) {

if (Is_earthlevel(&u.uz)) {

if (uwep->blessed && !rn2(3)) {

mkcavearea(FALSE);

goto cleanup;

} else if ((uwep->cursed && !rn2(4))

|| (!uwep->blessed && !rn2(6))) {

mkcavearea(TRUE);

goto cleanup;

}

}

if (digtyp == DIGTYP_TREE) {

digtxt = "You cut down the tree.";

lev->typ = ROOM, lev->flags = 0;

if (!rn2(5))

(void) rnd_treefruit_at(dpx, dpy);

if (Race_if(PM_ELF) || Role_if(PM_RANGER))

adjalign(-1);

} else {

digtxt = "You succeed in cutting away some rock.";

lev->typ = CORR, lev->flags = 0;

}

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

if (shopedge) {

add_damage(dpx, dpy, SHOP_WALL_DMG);

dmgtxt = "damage";

}

if (svl.level.flags.is_maze_lev) {

lev->typ = ROOM, lev->flags = 0;

} else if (svl.level.flags.is_cavernous_lev

&& !in_town(dpx, dpy)) {

lev->typ = CORR, lev->flags = 0;

} else {

lev->typ = DOOR, lev->doormask = D_NODOOR;

}

digtxt = "You make an opening in the wall.";

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

cvt_sdoor_to_door(lev); /* ->typ = DOOR */

digtxt = "You break through a secret door!";

if (!(lev->doormask & D_TRAPPED))

lev->doormask = D_BROKEN;

} else if (closed_door(dpx, dpy)) {

Sprintf(digbuf, "You break through the door with your %s.",

simpleonames(uwep));

digtxt = digbuf;

if (shopedge) {

add_damage(dpx, dpy, SHOP_DOOR_COST);

dmgtxt = "break";

}

if (!(lev->doormask & D_TRAPPED))

lev->doormask = D_BROKEN;

} else

return 0; /* statue or boulder got taken */

if (!does_block(dpx, dpy, &levl[dpx][dpy]))

unblock_point(dpx, dpy); /* vision: can see through */

feel_newsym(dpx, dpy);

if (digtxt && !svc.context.digging.quiet)

pline1(digtxt); /* after newsym */

if (dmgtxt)

pay_for_damage(dmgtxt, FALSE);

if (Is_earthlevel(&u.uz) && !rn2(3)) {

int mndx = rn2(2) ? PM_EARTH_ELEMENTAL : PM_XORN;

if (makemon(&mons[mndx], dpx, dpy, MM_NOMSG))

pline_The("debris from your digging comes to life!");

}

if (IS_DOOR(lev->typ) && (lev->doormask & D_TRAPPED)) {

lev->doormask = D_NODOOR;

b_trapped("door", NO_PART);

recalc_block_point(dpx, dpy);

newsym(dpx, dpy);

}

cleanup:

svc.context.digging.lastdigtime = svm.moves;

svc.context.digging.quiet = FALSE;

svc.context.digging.level.dnum = 0;

svc.context.digging.level.dlevel = -1;

return 0;

} else { /* not enough effort has been spent yet */

static const char *const d_target[6] = { "", "rock", "statue",

"boulder", "door", "tree" };

int dig_target = dig_typ(uwep, dpx, dpy);

if (IS_WALL(lev->typ) || dig_target == DIGTYP_DOOR) {

if (*in_rooms(dpx, dpy, SHOPBASE)) {

pline("This %s seems too hard to %s.",

IS_DOOR(lev->typ) ? "door" : "wall", verb);

return 0;

}

} else if (dig_target == DIGTYP_UNDIGGABLE

|| (dig_target == DIGTYP_ROCK && !IS_OBSTRUCTED(lev->typ)))

return 0; /* statue or boulder got taken */

if (!gd.did_dig_msg) {

You("hit the %s with all your might.", d_target[dig_target]);

wake_nearby(FALSE);

gd.did_dig_msg = TRUE;

}

}

return 1;

}

staticfn boolean

furniture_handled(coordxy x, coordxy y, boolean madeby_u)

{

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

if (IS_FOUNTAIN(lev->typ)) {

dogushforth(FALSE);

SET_FOUNTAIN_WARNED(x, y); /* force dryup */

dryup(x, y, madeby_u);

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

breaksink(x, y);

} else if (lev->typ == DRAWBRIDGE_DOWN

|| (is_drawbridge_wall(x, y) >= 0)) {

coordxy bx = x, by = y;

/* if under the portcullis, the bridge is adjacent */

(void) find_drawbridge(&bx, &by);

destroy_drawbridge(bx, by);

} else {

return FALSE;

}

return TRUE;

}

/* When will hole be finished? Very rough indication used by shopkeeper. */

int

holetime(void)

{

if (go.occupation != dig || !*u.ushops)

return -1;

return ((250 - svc.context.digging.effort) / 20);

}

/* Return typ of liquid to fill a hole with, or ROOM, if no liquid nearby */

schar

fillholetyp(coordxy x, coordxy y,

boolean fill_if_any) /* force filling if it exists at all */

{

coordxy x1, y1;

coordxy lo_x = max(1, x - 1), hi_x = min(x + 1, COLNO - 1),

lo_y = max(0, y - 1), hi_y = min(y + 1, ROWNO - 1);

int pool_cnt = 0, moat_cnt = 0, lava_cnt = 0;

for (x1 = lo_x; x1 <= hi_x; x1++)

for (y1 = lo_y; y1 <= hi_y; y1++)

if (is_moat(x1, y1))

moat_cnt++;

else if (is_pool(x1, y1))

/* This must come after is_moat since moats are pools

* but not vice-versa. */

pool_cnt++;

else if (is_lava(x1, y1))

lava_cnt++;

if (!fill_if_any)

pool_cnt /= 3; /* not as much liquid as the others */

if ((lava_cnt > moat_cnt + pool_cnt && rn2(lava_cnt + 1))

|| (lava_cnt && fill_if_any))

return LAVAPOOL;

else if ((moat_cnt > 0 && rn2(moat_cnt + 1)) || (moat_cnt && fill_if_any))

return MOAT;

else if ((pool_cnt > 0 && rn2(pool_cnt + 1)) || (pool_cnt && fill_if_any))

return POOL;

else

return ROOM;

}

void

digactualhole(coordxy x, coordxy y, struct monst *madeby, int ttyp)

{

struct obj *oldobjs, *newobjs;

struct trap *ttmp;

const char *surface_type, *tname, *in_thru;

char furniture[BUFSZ];

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

struct monst *mtmp = m_at(x, y); /* may be madeby */

boolean madeby_u = (madeby == BY_YOU), madeby_obj = (madeby == BY_OBJECT),

/* BY_OBJECT means the hero broke a wand, so blame her for it */

heros_fault = (madeby_u || madeby_obj);

boolean shopdoor, at_u = u_at(x, y), wont_fall = Levitation || Flying;

int old_typ, old_aligntyp = A_NONE;

if (at_u && u.utrap) {

if (u.utraptype == TT_BURIEDBALL)

buried_ball_to_punishment();

else if (u.utraptype == TT_INFLOOR)

reset_utrap(FALSE);

}

if (furniture_handled(x, y, madeby_u))

return;

if (ttyp != PIT && (!Can_dig_down(&u.uz) && !lev->candig)) {

impossible("digactualhole: can't dig %s on this level.",

trapname(ttyp, TRUE));

ttyp = PIT;

}

/* maketrap() might change terrain type but we deliver messages after

that, so prepare in advance */

old_typ = lev->typ;

furniture[0] = '\0';

if (IS_FURNITURE(lev->typ)) {

/* should mirror the word used by surface() for normal floor */

surface_type = (IS_ROOM(lev->typ) && !Is_earthlevel(&u.uz)

? "floor" : "ground");

if (IS_ALTAR(lev->typ)) {

old_aligntyp = Amask2align(levl[x][y].altarmask & AM_MASK);

Strcpy(furniture, align_str(old_aligntyp));

Strcat(furniture, " ");

}

Strcat(furniture, surface(x, y));

} else {

surface_type = surface(x, y);

}

shopdoor = IS_DOOR(lev->typ) && *in_rooms(x, y, SHOPBASE);

oldobjs = svl.level.objects[x][y];

ttmp = maketrap(x, y, ttyp);

if (!ttmp)

return;

newobjs = svl.level.objects[x][y];

ttmp->madeby_u = heros_fault;

ttmp->tseen = 0;

if (cansee(x, y))

seetrap(ttmp);

else if (madeby_u)

feeltrap(ttmp);

tname = trapname(ttyp, TRUE);

in_thru = (ttyp == HOLE ? "through" : "in");

if (madeby_u) {

if (x != u.ux || y != u.uy)

You("dig an adjacent %s.", tname);

else

You("dig %s %s the %s.", an(tname), in_thru, surface_type);

} else if (!madeby_obj && canseemon(madeby)) {

pline("%s digs %s %s the %s.", Monnam(madeby), an(tname), in_thru,

surface_type);

} else if (cansee(x, y) && flags.verbose) {

if (IS_STWALL(old_typ))

pline_The("%s crumbles into %s.", surface_type, an(tname));

else

pline("%s appears in the %s.", An(tname), surface_type);

}

if (IS_FURNITURE(old_typ) && cansee(x, y))

pline_The("%s falls into the %s!", furniture, tname);

/* wrath should immediately follow altar destruction message */

if (heros_fault && old_typ == ALTAR)

desecrate_altar(FALSE, old_aligntyp);

/* now deal with actual post-trap creation effects */

if (ttyp == PIT) {

if (shopdoor && heros_fault)

pay_for_damage("ruin", FALSE);

else

add_damage(x, y, heros_fault ? SHOP_PIT_COST : 0L);

if (madeby_u)

wake_nearby(FALSE);

/* in case we're digging down while encased in solid rock

which is blocking levitation or flight */

switch_terrain();

if (Levitation || Flying)

wont_fall = TRUE;

if (at_u) {

if (!wont_fall) {

set_utrap(rn1(4, 2), TT_PIT);

gv.vision_full_recalc = 1; /* vision limits change */

} else

reset_utrap(TRUE);

if (oldobjs != newobjs) /* something unearthed */

(void) pickup(1); /* detects pit */

} else if (mtmp) {

if (is_flyer(mtmp->data) || is_floater(mtmp->data)) {

if (canseemon(mtmp))

pline("%s %s over the pit.", Monnam(mtmp),

(is_flyer(mtmp->data)) ? "flies" : "floats");

} else if (mtmp != madeby)

(void) mintrap(mtmp, NO_TRAP_FLAGS);

}

} else { /* was TRAPDOOR now a HOLE*/

if (at_u) {

/* in case we're digging down while encased in solid rock

which is blocking levitation or flight */

switch_terrain();

if (Levitation || Flying)

wont_fall = TRUE;

/* check for leashed pet that can't fall right now */

if (!u.ustuck && !wont_fall && !next_to_u()) {

You("are jerked back by your pet!");

wont_fall = TRUE;

}

/* Floor objects get a chance of falling down. The case where

* the hero does NOT fall down is treated here. The case

* where the hero does fall down is treated in goto_level().

*/

if (u.ustuck || wont_fall) {

if (newobjs)

impact_drop((struct obj *) 0, x, y, 0);

if (oldobjs != newobjs)

(void) pickup(1);

if (shopdoor && heros_fault)

pay_for_damage("ruin", FALSE);

} else {

d_level newlevel;

if (*u.ushops && heros_fault)

shopdig(1); /* shk might snatch pack */

else /* handle any earlier hero-caused damage */

pay_for_damage("dig into", TRUE);

You("fall through...");

/* Earlier checks must ensure that the destination

* level exists and is in the present dungeon.

*/

newlevel.dnum = u.uz.dnum;

newlevel.dlevel = u.uz.dlevel + 1;

goto_level(&newlevel, FALSE, TRUE, FALSE);

/* messages for arriving in special rooms */

spoteffects(FALSE);

}

} else {

if (shopdoor && heros_fault)

pay_for_damage("ruin", FALSE);

if (newobjs)

impact_drop((struct obj *) 0, x, y, 0);

if (mtmp) {

/*[don't we need special sokoban handling here?]*/

if (!grounded(mtmp->data)

|| (mtmp->wormno && count_wsegs(mtmp) > 5)

|| mtmp->data->msize >= MZ_HUGE)

return;

if (mtmp == u.ustuck) /* probably a vortex */

return; /* temporary? kludge */

if (teleport_pet(mtmp, FALSE)) {

d_level tolevel;

if (Is_stronghold(&u.uz)) {

assign_level(&tolevel, &valley_level);

} else if (Is_botlevel(&u.uz)) {

if (canseemon(mtmp))

pline("%s avoids the trap.", Monnam(mtmp));

return;

} else {

get_level(&tolevel, depth(&u.uz) + 1);

}

if (mtmp->isshk)

make_angry_shk(mtmp, 0, 0);

migrate_to_level(mtmp, ledger_no(&tolevel),

MIGR_RANDOM, (coord *) 0);

}

}

}

}

}

DISABLE_WARNING_FORMAT_NONLITERAL

/*

* Called from dighole(); also from do_break_wand() in apply.c

* and do_earthquake() in music.c.

*/

void

liquid_flow(

coordxy x, coordxy y,

schar typ,

struct trap *ttmp,

const char *fillmsg)

{

struct obj *objchain;

struct monst *mon;

boolean u_spot = u_at(x, y);

/* caller should have changed levl[x][y].typ to POOL, MOAT, or LAVA */

if (!is_pool_or_lava(x, y)) {

if (iflags.sanity_check) {

impossible("Insane liquid_flow(%d,%d,%s,%s).", x, y,

ttmp ? trapname(ttmp->ttyp, TRUE) : "no trap",

fillmsg ? fillmsg : "no mesg");

}

return;

}

if (ttmp)

(void) delfloortrap(ttmp); /* will untrap monster if one is here */

/* if any objects were frozen here, they're released now */

obj_ice_effects(x, y, TRUE);

unearth_objs(x, y);

if (fillmsg)

pline(fillmsg, hliquid(typ == LAVAPOOL ? "lava" : "water"));

/* handle object damage before hero damage; affects potential bones */

if ((objchain = svl.level.objects[x][y]) != 0) {

if (typ == LAVAPOOL)

fire_damage_chain(objchain, TRUE, TRUE, x, y);

else

water_damage_chain(objchain, TRUE);

}

/* damage to the hero */

if (u_spot) {

(void) pooleffects(FALSE);

} else if ((mon = m_at(x, y)) != 0) {

(void) minliquid(mon);

}

}

RESTORE_WARNING_FORMAT_NONLITERAL

/* return TRUE if digging succeeded, FALSE otherwise */

boolean

dighole(boolean pit_only, boolean by_magic, coord *cc)

{

struct trap *ttmp;

struct rm *lev;

struct obj *boulder_here;

schar typ, old_typ;

coordxy dig_x, dig_y;

boolean nohole, retval = FALSE;

enum digcheck_result dig_check_result;

if (!cc) {

dig_x = u.ux;

dig_y = u.uy;

} else {

dig_x = cc->x;

dig_y = cc->y;

if (!isok(dig_x, dig_y))

return FALSE;

}

ttmp = t_at(dig_x, dig_y);

lev = &levl[dig_x][dig_y];

dig_check_result = dig_check(BY_YOU, dig_x, dig_y);

/* nohole = (!Can_dig_down(&u.uz) && !lev->candig); */

nohole = (dig_check_result == DIGCHECK_FAIL_CANTDIG

|| dig_check_result == DIGCHECK_FAIL_TOOHARD);

old_typ = lev->typ;

if ((ttmp && (undestroyable_trap(ttmp->ttyp) || nohole))

|| (IS_OBSTRUCTED(old_typ) && old_typ != SDOOR

&& (lev->wall_info & W_NONDIGGABLE) != 0)) {

pline_The("%s %shere is too hard to dig in.", surface(dig_x, dig_y),

(dig_x != u.ux || dig_y != u.uy) ? "t" : "");

} else if (ttmp && is_magical_trap(ttmp->ttyp)) {

explode(dig_x, dig_y, 0, 20 + d(3, 6), TRAP_EXPLODE, EXPL_MAGICAL);

deltrap(ttmp);

newsym(dig_x, dig_y);

} else if (is_pool_or_lava(dig_x, dig_y)) {

pline_The("%s sloshes furiously for a moment, then subsides.",

hliquid(is_lava(dig_x, dig_y) ? "lava" : "water"));

wake_nearby(FALSE); /* splashing */

} else if (old_typ == DRAWBRIDGE_DOWN

|| (is_drawbridge_wall(dig_x, dig_y) >= 0)) {

/* drawbridge_down is the platform crossing the moat when the

bridge is extended; drawbridge_wall is the open "doorway" or

closed "door" where the portcullis/mechanism is located */

if (pit_only) {

pline_The("drawbridge seems too hard to dig through.");

} else {

coordxy x = dig_x, y = dig_y;

/* if under the portcullis, the bridge is adjacent */

(void) find_drawbridge(&x, &y);

destroy_drawbridge(x, y);

retval = TRUE;

}

} else if ((boulder_here = sobj_at(BOULDER, dig_x, dig_y)) != 0) {

if (ttmp && is_pit(ttmp->ttyp)

&& rn2(2)) {

pline_The("boulder settles into the %spit.",

(dig_x != u.ux || dig_y != u.uy) ? "adjacent " : "");

ttmp->ttyp = PIT; /* crush spikes */

} else {

/*

* digging makes a hole, but the boulder immediately

* fills it. Final outcome: no hole, no boulder.

*/

Soundeffect(se_kadoom_boulder_falls_in, 60);

pline("KADOOM! The boulder falls in!");

wake_nearby(FALSE);

(void) delfloortrap(ttmp);

}

delobj(boulder_here);

} else if (IS_GRAVE(old_typ)) {

digactualhole(dig_x, dig_y, BY_YOU, PIT);

dig_up_grave(cc);

retval = TRUE;

} else if (old_typ == DRAWBRIDGE_UP) {

/* must be floor or ice, other cases handled above */

/* dig "pit" and let fluid flow in (if possible) */

typ = fillholetyp(dig_x, dig_y, FALSE);

if (typ == ROOM) {

/*

* We can't dig a hole here since that will destroy

* the drawbridge. The following is a cop-out. --dlc

*/

pline_The("%s %shere is too hard to dig in.",

surface(dig_x, dig_y),

(dig_x != u.ux || dig_y != u.uy) ? "t" : "");

} else {

lev->drawbridgemask &= ~DB_UNDER;

lev->drawbridgemask |= (typ == LAVAPOOL) ? DB_LAVA : DB_MOAT;

liquid_flow(dig_x, dig_y, typ, ttmp,

"As you dig, the hole fills with %s!");

retval = TRUE;

}

/* the following two are here for the wand of digging */

} else if (IS_THRONE(old_typ)) {

pline_The("throne is too hard to break apart.");

} else if (IS_ALTAR(old_typ)) {

pline_The("altar is too hard to break apart.");

} else {

typ = fillholetyp(dig_x, dig_y, FALSE);

lev->flags = 0;

if (typ != ROOM) {

if (!furniture_handled((int) dig_x, (int) dig_y, TRUE)) {

lev->typ = typ;

liquid_flow(dig_x, dig_y, typ, ttmp,

"As you dig, the hole fills with %s!");

}