#include "hack.h"

STATIC_PTR int NDECL(prayer_done);

STATIC_DCL struct obj *NDECL(worst_cursed_item);

STATIC_DCL int NDECL(in_trouble);

STATIC_DCL void FDECL(fix_worst_trouble, (int));

STATIC_DCL void FDECL(angrygods, (ALIGNTYP_P));

STATIC_DCL void FDECL(at_your_feet, (const char *));

STATIC_DCL void NDECL(gcrownu);

STATIC_DCL void FDECL(pleased, (ALIGNTYP_P));

STATIC_DCL void FDECL(godvoice, (ALIGNTYP_P, const char *));

STATIC_DCL void FDECL(god_zaps_you, (ALIGNTYP_P));

STATIC_DCL void FDECL(fry_by_god, (ALIGNTYP_P, BOOLEAN_P));

STATIC_DCL void FDECL(gods_angry, (ALIGNTYP_P));

STATIC_DCL void FDECL(gods_upset, (ALIGNTYP_P));

STATIC_DCL void FDECL(consume_offering, (struct obj *));

STATIC_DCL boolean FDECL(water_prayer, (BOOLEAN_P));

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

#define Cursed_obj(obj, typ) ((obj) && (obj)->otyp == (typ) && (obj)->cursed)

static const char *Moloch = "Moloch";

static const char *godvoices[] = {

"booms out", "thunders", "rings out", "booms",

};

static const char *hgodvoices[] = {

"ka-BOOMs out", "belches", "ring-a-lings out", "squeaks",

"squeals", "screeches", "drones", "buzzes", "pipes",

"tinkles", "rumbulates", "moos", "brays", "barks", "screeeeeeeeams"

};

static aligntyp p_aligntyp;

static int p_trouble;

static int p_type; /* (-1)-3: (-1)=really naughty, 3=really good */

#define TROUBLE_STONED 18

#define TROUBLE_SLIMED 17

#define TROUBLE_STRANGLED 16

#define TROUBLE_LAVA 15

#define TROUBLE_SICK 14

#define TROUBLE_WITHERING 13

#define TROUBLE_STARVING 12

#define TROUBLE_CARRIER 11

#define TROUBLE_REGION 10 /* stinking cloud */

#define TROUBLE_SURROUNDED 9

#define TROUBLE_HIT_CRITICAL 8

#define TROUBLE_LYCANTHROPE 7

#define TROUBLE_COLLAPSING 6

#define TROUBLE_STUCK_IN_WALL 5

#define TROUBLE_CURSED_LEVITATION 4

#define TROUBLE_UNUSEABLE_HANDS 3

#define TROUBLE_CURSED_BLINDFOLD 2

#define TROUBLE_HIT_MAJOR 1

#define TROUBLE_HIT_MID (-1)

#define TROUBLE_PUNISHED (-2)

#define TROUBLE_FUMBLING (-3)

#define TROUBLE_CURSED_ITEMS (-4)

#define TROUBLE_SADDLE (-5)

#define TROUBLE_HIT_MINOR (-6)

#define TROUBLE_BLIND (-7)

#define TROUBLE_POISONED (-8)

#define TROUBLE_WOUNDED_LEGS (-9)

#define TROUBLE_HUNGRY (-10)

#define TROUBLE_STUNNED (-11)

#define TROUBLE_CONFUSED (-12)

#define TROUBLE_HALLUCINATION (-13)

#define ugod_is_angry() (u.ualign.record < 0)

#define on_altar() IS_ALTAR(levl[u.ux][u.uy].typ)

#define on_shrine() ((levl[u.ux][u.uy].altarmask & AM_SHRINE) != 0)

critically_low_hp(only_if_injured, multiplier)

boolean only_if_injured; /* determines whether maxhp <= 5 matters */

int multiplier;

{

int divisor, hplim, curhp = Upolyd ? u.mh : u.uhp,

maxhp = Upolyd ? u.mhmax : u.uhpmax;

if (only_if_injured && !(curhp < maxhp))

return FALSE;

/* if maxhp is extremely high, use lower threshold for the division test

hplim = 15 * u.ulevel;

if (maxhp > hplim)

maxhp = hplim;

/* 7 used to be the unconditional divisor - these are multiplied by 2,

divisor = 10 + xlev_to_rank(u.ulevel);

/* 5 is a magic number in TROUBLE_HIT handling below */

return (boolean) (curhp <= 5 || curhp * divisor <= maxhp * multiplier);

}

stuck_in_wall()

{

int i, j, x, y, count = 0;

if (Passes_walls)

return FALSE;

for (i = -1; i <= 1; i++) {

x = u.ux + i;

for (j = -1; j <= 1; j++) {

if (!i && !j)

continue;

y = u.uy + j;

if (!isok(x, y)

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

&& (levl[x][y].typ != SDOOR && levl[x][y].typ != SCORR))

|| (blocked_boulder(i, j) && !throws_rocks(youmonst.data)))

++count;

}

}

return (count == 8) ? TRUE : FALSE;

}

starvingCount(otmp, food, hiddenfood, toplevel)

struct obj *otmp;

long *food;

long *hiddenfood;

boolean toplevel;

{

long value = 0;

if (otmp->oclass == FOOD_CLASS) {

switch(otmp->otyp) {

case TIN:

case EGG:

case TRIPE_RATION:

case PINCH_OF_CATNIP:

case CLOVE_OF_GARLIC:

case SPRIG_OF_WOLFSBANE:

case EUCALYPTUS_LEAF:

/* ignore */

break;

case GLOB_OF_GRAY_OOZE:

case GLOB_OF_BROWN_PUDDING:

case GLOB_OF_GREEN_SLIME:

case GLOB_OF_BLACK_PUDDING:

case CORPSE: {

int pm = otmp->corpsenm;

if (otmp->otyp == GLOB_OF_GRAY_OOZE)

pm = PM_GRAY_OOZE;

if (otmp->otyp == GLOB_OF_BROWN_PUDDING)

pm = PM_BROWN_PUDDING;

if (otmp->otyp == GLOB_OF_GREEN_SLIME)

pm = PM_GREEN_SLIME;

if (otmp->otyp == GLOB_OF_BLACK_PUDDING)

pm = PM_BLACK_PUDDING;

/* Not if it is slime */

if ((pm == PM_GREEN_SLIME) &&

(!Unchanging && !slimeproof(youmonst.data)))

break;

/* or petrifying */

if ((flesh_petrifies(&mons[pm])) && !Stone_resistance)

break;

/* or poisonous */

if (poisonous(&mons[pm]) && !Poison_resistance)

break;

/* or acidic */

if (acidic(&mons[pm]) && !Acid_resistance && (u.uhp > 15))

break;

/* or a lizard */

if (pm == PM_LIZARD)

break;

/* or tainted - you don't know this precisely, not just because you haven't

if (!nonrotting_corpse(pm) && !Sick_resistance) {

long age = peek_at_iced_corpse_age(otmp);

int rotted = (monstermoves - age) / 10L;

if (otmp->bknown) {

if (otmp->cursed)

rotted += 2L;

else if (otmp->blessed)

rotted -= 2L;

} else

rotted += 2L;

if (rotted > 3L)

break;

}

/* or cannibal / domestic animal */

if (is_cannibal(pm) || is_inedible_pet(pm))

break;

}

/* fall thru */

default:

value = obj_nutrition(otmp);

}

} else if (Has_contents(otmp)) {

struct obj *ot;

for (ot = otmp->cobj; ot; ot = ot->nobj)

starvingCount(ot, &food, &hiddenfood, FALSE);

}

if (toplevel)

*food += value;

else

*hiddenfood += value;

}

starving()

{

long food = 0;

long hiddenfood = 0;

long rate;

struct obj *otmp;

if (u.uhs < WEAK) return FALSE;

/* Recursively descend into containers to find food. Returns two counts for

for (otmp = invent; otmp; otmp = otmp->nobj)

starvingCount(otmp, &food, &hiddenfood, TRUE);

/* Include food in containers if containers are accessible to you */

if (!(nohands(youmonst.data) || !freehand()))

food += hiddenfood;

/* Convert to turns, based on the hunger rate. */

rate = hungerrate();

if (rate <= 1) rate = 1;

food /= rate;

/* You are 'starving' if you have less than the equivalent of a fortune cookie

return (food < 2);

}

surrounded()

{

int monsters = 0;

int freespace = 0;

int i, j, x, y;

/* Count monsters and blocked grids */

for(i = -4; i <= 4; i++) {

x = u.ux + i;

for(j = -4; j <= 4; j++) {

if ((i != 0) || (j != 0)) {

boolean ok = FALSE;

boolean mon = FALSE;

int dist;

y = u.uy + j;

if (isok(x, y)) {

ok = TRUE;

if (IS_ROCK(levl[x][y].typ)) ok = FALSE;

if (m_at(x, y) != 0) {

ok = FALSE;

if (!(m_at(x, y)->mtame)) {

mon = TRUE;

}

}

}

dist = isqrt((i*i)+(j*j));

if (mon) monsters += (1000 / dist);

if (ok) freespace += (1000 / (dist*dist));

}

}

}

if (freespace == 0) return TRUE;

return (monsters >= freespace);

}

STATIC_OVL int

in_trouble()

{

struct obj *otmp;

int i;

/*

if (Stoned)

return TROUBLE_STONED;

if (Slimed)

return TROUBLE_SLIMED;

if (Strangled)

return TROUBLE_STRANGLED;

if (u.utrap && u.utraptype == TT_LAVA)

return TROUBLE_LAVA;

if (Sick)

return TROUBLE_SICK;

if (Withering)

return TROUBLE_WITHERING;

if (starving())

return TROUBLE_STARVING;

if (LarvaCarrier)

return TROUBLE_CARRIER;

if (region_danger())

return TROUBLE_REGION;

if (surrounded())

return TROUBLE_SURROUNDED;

if (critically_low_hp(FALSE, 2))

return TROUBLE_HIT_CRITICAL;

if ((u.ulycn >= LOW_PM) && !Race_if(PM_HUMAN_WEREWOLF))

return TROUBLE_LYCANTHROPE;

if (near_capacity() >= EXT_ENCUMBER && AMAX(A_STR) - ABASE(A_STR) > 3)

return TROUBLE_COLLAPSING;

if (stuck_in_wall())

return TROUBLE_STUCK_IN_WALL;

if (Cursed_obj(uarmf, LEVITATION_BOOTS)

|| stuck_ring(uleft, RIN_LEVITATION)

|| stuck_ring(uright, RIN_LEVITATION))

return TROUBLE_CURSED_LEVITATION;

if (nohands(youmonst.data) || !freehand()) {

/* for bag/box access [cf use_container()]...

if (welded(uwep))

return TROUBLE_UNUSEABLE_HANDS;

if (Upolyd && nohands(youmonst.data)

&& (!Unchanging || ((otmp = unchanger()) != 0 && otmp->cursed)))

return TROUBLE_UNUSEABLE_HANDS;

}

if (Blindfolded && ublindf->cursed)

return TROUBLE_CURSED_BLINDFOLD;

if (critically_low_hp(FALSE, 3))

return TROUBLE_HIT_MAJOR;

/*

if (critically_low_hp(FALSE, 5))

return TROUBLE_HIT_MID;

if (Punished || (u.utrap && u.utraptype == TT_BURIEDBALL))

return TROUBLE_PUNISHED;

if (Cursed_obj(uarmg, GAUNTLETS_OF_FUMBLING)

|| Cursed_obj(uarmf, FUMBLE_BOOTS))

return TROUBLE_FUMBLING;

if (worst_cursed_item())

return TROUBLE_CURSED_ITEMS;

if (u.usteed) { /* can't voluntarily dismount from a cursed saddle */

otmp = which_armor(u.usteed, W_SADDLE);

if (Cursed_obj(otmp, SADDLE))

return TROUBLE_SADDLE;

}

if (critically_low_hp(FALSE, 6))

return TROUBLE_HIT_MINOR;

if (Blinded > 1 && haseyes(youmonst.data)

&& (!u.uswallow

|| !attacktype_fordmg(u.ustuck->data, AT_ENGL, AD_BLND)))

return TROUBLE_BLIND;

/* deafness isn't it's own trouble; healing magic cures deafness

if ((HDeaf & TIMEOUT) > 1L)

return TROUBLE_BLIND;

for (i = 0; i < A_MAX; i++)

if (ABASE(i) < AMAX(i))

return TROUBLE_POISONED;

if (Wounded_legs && !u.usteed)

return TROUBLE_WOUNDED_LEGS;

if (u.uhs >= HUNGRY)

return TROUBLE_HUNGRY;

if (HStun & TIMEOUT)

return TROUBLE_STUNNED;

if (HConfusion & TIMEOUT)

return TROUBLE_CONFUSED;

if (HHallucination & TIMEOUT)

return TROUBLE_HALLUCINATION;

return 0;

}

STATIC_OVL struct obj *

worst_cursed_item()

{

register struct obj *otmp;

/* if strained or worse, check for loadstone first */

if (near_capacity() >= HVY_ENCUMBER) {

for (otmp = invent; otmp; otmp = otmp->nobj)

if (Cursed_obj(otmp, LOADSTONE))

return otmp;

}

/* weapon takes precedence if it is interfering

if (welded(uwep) && (uright || bimanual(uwep))) { /* weapon */

otmp = uwep;

/* gloves come next, due to rings */

} else if (uarmg && uarmg->cursed) { /* gloves */

otmp = uarmg;

/* then shield due to two handed weapons and spells */

} else if (uarms && uarms->cursed) { /* shield */

otmp = uarms;

/* then cloak due to body armor */

} else if (uarmc && uarmc->cursed) { /* cloak */

otmp = uarmc;

} else if (uarm && uarm->cursed) { /* suit */

otmp = uarm;

/* if worn helmet of opposite alignment is making you an adherent

} else if (uarmh && uarmh->cursed /* helmet */

&& uarmh->otyp != HELM_OF_OPPOSITE_ALIGNMENT) {

otmp = uarmh;

} else if (uarmf && uarmf->cursed) { /* boots */

otmp = uarmf;

} else if (uarmu && uarmu->cursed) { /* shirt */

otmp = uarmu;

} else if (uamul && uamul->cursed) { /* amulet */

otmp = uamul;

} else if (uleft && uleft->cursed) { /* left ring */

otmp = uleft;

} else if (uright && uright->cursed) { /* right ring */

otmp = uright;

} else if (ublindf && ublindf->cursed) { /* eyewear */

otmp = ublindf; /* must be non-blinding lenses */

/* if weapon wasn't handled above, do it now */

} else if (welded(uwep)) { /* weapon */

otmp = uwep;

/* active secondary weapon even though it isn't welded */

} else if (uswapwep && uswapwep->cursed && u.twoweap) {

otmp = uswapwep;

/* all worn items ought to be handled by now */

} else {

for (otmp = invent; otmp; otmp = otmp->nobj) {

if (!otmp->cursed)

continue;

if (otmp->otyp == LOADSTONE || confers_luck(otmp))

break;

}

}

return otmp;

}

STATIC_OVL void

fix_worst_trouble(trouble)

int trouble;

{

int i;

struct obj *otmp = 0;

const char *what = (const char *) 0;

static NEARDATA const char leftglow[] = "Your left ring softly glows",

rightglow[] = "Your right ring softly glows";

switch (trouble) {

case TROUBLE_STONED:

make_stoned(0L, "You feel more limber.", 0, (char *) 0);

break;

case TROUBLE_SLIMED:

make_slimed(0L, "The slime disappears.");

break;

case TROUBLE_STRANGLED:

if (uamul && uamul->otyp == AMULET_OF_STRANGULATION) {

Your("amulet vanishes!");

useup(uamul);

}

You("can breathe again.");

Strangled = 0;

context.botl = 1;

break;

case TROUBLE_LAVA:

You("are back on solid ground.");

/* teleport should always succeed, but if not, just untrap them */

if (!safe_teleds(FALSE))

reset_utrap(TRUE);

break;

case TROUBLE_STARVING:

/* temporarily lost strength recovery now handled by init_uhunger() */

/*FALLTHRU*/

case TROUBLE_HUNGRY:

Your("%s feels content.", body_part(STOMACH));

init_uhunger();

context.botl = 1;

break;

case TROUBLE_SICK:

You_feel("better.");

make_sick(0L, (char *) 0, FALSE, SICK_ALL);

break;

case TROUBLE_WITHERING:

You_feel("hardier.");

set_itimeout(&HWithering, (long) 0);

break;

case TROUBLE_CARRIER:

You_feel("the things infesting you vanish.");

make_carrier(0L, TRUE);

break;

case TROUBLE_REGION:

/* stinking cloud, with hero vulnerable to HP loss */

region_safety();

break;

case TROUBLE_SURROUNDED:

safe_teleds(FALSE);

if (!critically_low_hp(FALSE, 2)) break;

/*FALLTHRU*/

case TROUBLE_HIT_CRITICAL:

case TROUBLE_HIT_MAJOR:

case TROUBLE_HIT_MID:

case TROUBLE_HIT_MINOR:

/* "fix all troubles" will keep trying if hero has

You_feel("much better.");

if (Upolyd) {

u.mhmax += rnd(5);

if (u.mhmax <= 5)

u.mhmax = 5 + 1;

u.mh = u.mhmax;

}

if (u.uhpmax < u.ulevel * 5 + 11)

u.uhpmax += rnd(5);

if (u.uhpmax <= 5)

u.uhpmax = 5 + 1;

u.uhp = u.uhpmax;

context.botl = 1;

break;

case TROUBLE_COLLAPSING:

/* override Fixed_abil; uncurse that if feasible */

You_feel("%sstronger.",

(AMAX(A_STR) - ABASE(A_STR) > 6) ? "much " : "");

ABASE(A_STR) = AMAX(A_STR);

context.botl = 1;

if (Fixed_abil) {

if ((otmp = stuck_ring(uleft, RIN_SUSTAIN_ABILITY)) != 0) {

if (otmp == uleft)

what = leftglow;

} else if ((otmp = stuck_ring(uright, RIN_SUSTAIN_ABILITY)) != 0) {

if (otmp == uright)

what = rightglow;

}

if (otmp)

goto decurse;

}

break;

case TROUBLE_STUCK_IN_WALL:

/* no control, but works on no-teleport levels */

if (safe_teleds(FALSE)) {

Your("surroundings change.");

} else {

/* safe_teleds() couldn't find a safe place; perhaps the

set_itimeout(&HPasses_walls, (long) (d(4, 4) + 4)); /* 8..20 */

/* how else could you move between packed rocks or among

You_feel("much slimmer.");

}

break;

case TROUBLE_CURSED_LEVITATION:

if (Cursed_obj(uarmf, LEVITATION_BOOTS)) {

otmp = uarmf;

} else if ((otmp = stuck_ring(uleft, RIN_LEVITATION)) != 0) {

if (otmp == uleft)

what = leftglow;

} else if ((otmp = stuck_ring(uright, RIN_LEVITATION)) != 0) {

if (otmp == uright)

what = rightglow;

}

goto decurse;

case TROUBLE_UNUSEABLE_HANDS:

if (welded(uwep)) {

otmp = uwep;

goto decurse;

}

if (Upolyd && nohands(youmonst.data)) {

if (!Unchanging) {

Your("shape becomes uncertain.");

rehumanize(); /* "You return to {normal} form." */

} else if ((otmp = unchanger()) != 0 && otmp->cursed) {

/* otmp is an amulet of unchanging */

goto decurse;

}

}

if (nohands(youmonst.data) || !freehand())

impossible("fix_worst_trouble: couldn't cure hands.");

break;

case TROUBLE_CURSED_BLINDFOLD:

otmp = ublindf;

goto decurse;

case TROUBLE_LYCANTHROPE:

you_unwere(TRUE);

break;

/*

case TROUBLE_PUNISHED:

Your("chain disappears.");

if (u.utrap && u.utraptype == TT_BURIEDBALL)

buried_ball_to_freedom();

else

unpunish();

break;

case TROUBLE_FUMBLING:

if (Cursed_obj(uarmg, GAUNTLETS_OF_FUMBLING))

otmp = uarmg;

else if (Cursed_obj(uarmf, FUMBLE_BOOTS))

otmp = uarmf;

goto decurse;

/*NOTREACHED*/

break;

case TROUBLE_CURSED_ITEMS:

otmp = worst_cursed_item();

if (otmp == uright)

what = rightglow;

else if (otmp == uleft)

what = leftglow;

decurse:

if (!otmp) {

impossible("fix_worst_trouble: nothing to uncurse.");

return;

}

if (otmp == uarmg && Glib) {

make_glib(0);

Your("%s are no longer slippery.", gloves_simple_name(uarmg));

if (!otmp->cursed)

break;

}

if (!Blind || (otmp == ublindf && Blindfolded_only)) {

pline("%s %s.",

what ? what : (const char *) Yobjnam2(otmp, "softly glow"),

hcolor(NH_AMBER));

iflags.last_msg = PLNMSG_OBJ_GLOWS;

otmp->bknown = !Hallucination; /* ok to skip set_bknown() */

}

uncurse(otmp);

update_inventory();

break;

case TROUBLE_POISONED:

/* override Fixed_abil; ignore items which confer that */

if (Hallucination)

pline("There's a tiger in your tank.");

else

You_feel("in good health again.");

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

if (ABASE(i) < AMAX(i)) {

ABASE(i) = AMAX(i);

context.botl = 1;

}

}

(void) encumber_msg();

break;

case TROUBLE_BLIND: { /* handles deafness as well as blindness */

char msgbuf[BUFSZ];

const char *eyes = body_part(EYE);

boolean cure_deaf = (HDeaf & TIMEOUT) ? TRUE : FALSE;

msgbuf[0] = '\0';

if (Blinded) {

if (eyecount(youmonst.data) != 1)

eyes = makeplural(eyes);

Sprintf(msgbuf, "Your %s %s better", eyes, vtense(eyes, "feel"));

u.ucreamed = 0;

make_blinded(0L, FALSE);

}

if (cure_deaf) {

make_deaf(0L, FALSE);

if (!Deaf)

Sprintf(eos(msgbuf), "%s can hear again",

!*msgbuf ? "You" : " and you");

}

if (*msgbuf)

pline("%s.", msgbuf);

break;

}

case TROUBLE_WOUNDED_LEGS:

heal_legs(0);

break;

case TROUBLE_STUNNED:

make_stunned(0L, TRUE);

break;

case TROUBLE_CONFUSED:

make_confused(0L, TRUE);

break;

case TROUBLE_HALLUCINATION:

pline("Looks like you are back in Kansas.");

(void) make_hallucinated(0L, FALSE, 0L);

break;

case TROUBLE_SADDLE:

otmp = which_armor(u.usteed, W_SADDLE);

if (!Blind) {

pline("%s %s.", Yobjnam2(otmp, "softly glow"), hcolor(NH_AMBER));

set_bknown(otmp, 1);

}

uncurse(otmp);

break;

}

}

STATIC_OVL void

god_zaps_you(resp_god)

aligntyp resp_god;

{

if (u.uswallow) {

pline(

"Suddenly a bolt of lightning comes down at you from the heavens!");

pline("It strikes %s!", mon_nam(u.ustuck));

if (!resists_elec(u.ustuck)) {

pline("%s fries to a crisp!", Monnam(u.ustuck));

/* Yup, you get experience. It takes guts to successfully

xkilled(u.ustuck, XKILL_NOMSG | XKILL_NOCONDUCT);

} else

pline("%s seems unaffected.", Monnam(u.ustuck));

} else {

pline("Suddenly, a bolt of lightning strikes you!");

if (Reflecting) {

shieldeff(u.ux, u.uy);

if (Blind)

pline("For some reason you're unaffected.");

else

(void) ureflects("%s reflects from your %s.", "It");

} else if (Shock_resistance) {

shieldeff(u.ux, u.uy);

pline("It seems not to affect you.");

} else

fry_by_god(resp_god, FALSE);

}

pline("%s is not deterred...", align_gname(resp_god));

if (u.uswallow) {

pline("A wide-angle disintegration beam aimed at you hits %s!",

mon_nam(u.ustuck));

if (!resists_disint(u.ustuck)) {

pline("%s disintegrates into a pile of dust!", Monnam(u.ustuck));

xkilled(u.ustuck, XKILL_NOMSG | XKILL_NOCORPSE | XKILL_NOCONDUCT);

} else

pline("%s seems unaffected.", Monnam(u.ustuck));

} else {

pline("A wide-angle disintegration beam hits you!");

/* disintegrate shield and body armor before disintegrating

if (uarms && !(EReflecting & W_ARMS)

&& !(EDisint_resistance & W_ARMS))

(void) destroy_arm(uarms);

if (uarmc && !(EReflecting & W_ARMC)

&& !(EDisint_resistance & W_ARMC))

(void) destroy_arm(uarmc);

if (uarm && !(EReflecting & W_ARM) && !(EDisint_resistance & W_ARM)

&& !uarmc)

(void) destroy_arm(uarm);

if (uarmu && !uarm && !uarmc)

(void) destroy_arm(uarmu);

if (!Disint_resistance) {

fry_by_god(resp_god, TRUE);

} else {

You("bask in its %s glow for a minute...", NH_BLACK);

godvoice(resp_god, "I believe it not!");

}

if (Is_astralevel(&u.uz) || Is_sanctum(&u.uz)) {

/* one more try for high altars */

verbalize("Thou cannot escape my wrath, mortal!");

summon_minion(resp_god, FALSE);

summon_minion(resp_god, FALSE);

summon_minion(resp_god, FALSE);

verbalize("Destroy %s, my servants!", uhim());

}

}

}

STATIC_OVL void

fry_by_god(resp_god, via_disintegration)

aligntyp resp_god;

boolean via_disintegration;

{

You("%s!", !via_disintegration ? "fry to a crisp"

: "disintegrate into a pile of dust");

killer.format = KILLED_BY;

Sprintf(killer.name, "the wrath of %s", align_gname(resp_god));

done(DIED);

}

STATIC_OVL void

angrygods(resp_god)

aligntyp resp_god;

{

int maxanger;

if (Inhell)

resp_god = A_NONE;

u.ublessed = 0;

/* changed from tmp = u.ugangr + abs (u.uluck) -- rph */

/* added test for alignment diff -dlc */

if (resp_god != u.ualign.type)

maxanger = u.ualign.record / 2 + (Luck > 0 ? -Luck / 3 : -Luck);

else

maxanger = 3 * u.ugangr + ((Luck > 0 || u.ualign.record >= STRIDENT)

? -Luck / 3

: -Luck);

if (maxanger < 1)

maxanger = 1; /* possible if bad align & good luck */

else if (maxanger > 15)

maxanger = 15; /* be reasonable */

switch (rn2(maxanger)) {

case 0:

case 1:

You_feel("that %s is %s.", align_gname(resp_god),

Hallucination ? "bummed" : "displeased");

break;

case 2:

case 3:

godvoice(resp_god, (char *) 0);

pline("\"Thou %s, %s.\"",

(ugod_is_angry() && resp_god == u.ualign.type)

? "hast strayed from the path"

: "art arrogant",

youmonst.data->mlet == S_HUMAN ? "mortal" : "creature");

verbalize("Thou must relearn thy lessons!");

(void) adjattrib(A_WIS, -1, FALSE);

losexp((char *) 0);

break;

case 6:

if (!Punished) {

gods_angry(resp_god);

punish((struct obj *) 0);

break;

} /* else fall thru */

case 4:

case 5:

gods_angry(resp_god);

if (!Blind && !Antimagic)

pline("%s glow surrounds you.", An(hcolor(NH_BLACK)));

rndcurse();

break;

case 7:

case 8:

godvoice(resp_god, (char *) 0);

verbalize("Thou durst %s me?",

(on_altar() && (a_align(u.ux, u.uy) != resp_god))

? "scorn"

: "call upon");

/* [why isn't this using verbalize()?] */

pline("\"Then die, %s!\"",

(youmonst.data->mlet == S_HUMAN) ? "mortal" : "creature");

summon_minion(resp_god, FALSE);

break;

default:

gods_angry(resp_god);

god_zaps_you(resp_god);

break;

}

u.ublesscnt = rnz(300);

holy_symbol();

return;

}

static void

at_your_feet(str)

const char *str;

{

if (Blind)

str = Something;

if (u.uswallow) {

/* barrier between you and the floor */

pline("%s %s into %s %s.", str, vtense(str, "drop"),

s_suffix(mon_nam(u.ustuck)), mbodypart(u.ustuck, STOMACH));

} else {

pline("%s %s %s your %s!", str,

Blind ? "lands" : vtense(str, "appear"),

Levitation ? "beneath" : "at", makeplural(body_part(FOOT)));

}

}

STATIC_OVL void

gcrownu()

{

struct obj *obj;

boolean already_exists, in_hand;

short class_gift;

int sp_no;

#define ok_wep(o) ((o) && ((o)->oclass == WEAPON_CLASS || is_weptool(o)))

HSee_invisible |= FROMOUTSIDE;

HFire_resistance |= FROMOUTSIDE;

HCold_resistance |= FROMOUTSIDE;

HShock_resistance |= FROMOUTSIDE;

HSleep_resistance |= FROMOUTSIDE;

HPoison_resistance |= FROMOUTSIDE;

godvoice(u.ualign.type, (char *) 0);

class_gift = STRANGE_OBJECT;

/* 3.3.[01] had this in the A_NEUTRAL case,

if (Role_if(PM_WIZARD)

&& (!uwep || (uwep->oartifact != ART_VORPAL_BLADE

&& uwep->oartifact != ART_STORMBRINGER))

&& !carrying(SPE_FINGER_OF_DEATH)) {