/* NetHack 5.0 mhitu.c $NHDT-Date: 1781973054 2026/06/20 16:30:54 $ $NHDT-Branch: NetHack-5.0 $:$NHDT-Revision: 1.347 $ */

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

/*-Copyright (c) Robert Patrick Rankin, 2012. */

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

#include "hack.h"

#include "artifact.h"

static NEARDATA struct obj *mon_currwep = (struct obj *) 0;

staticfn void missmu(struct monst *, boolean, struct attack *);

staticfn void mswings(struct monst *, struct obj *, boolean);

staticfn void wildmiss(struct monst *, struct attack *);

staticfn void calc_mattacku_vars(struct monst *, boolean *, boolean *,

boolean *, boolean *);

staticfn void summonmu(struct monst *, boolean);

staticfn int hitmu(struct monst *, struct attack *);

staticfn int gulpmu(struct monst *, struct attack *);

staticfn int explmu(struct monst *, struct attack *, boolean);

staticfn void mayberem(struct monst *, const char *, struct obj *,

const char *);

staticfn int assess_dmg(struct monst *, int);

staticfn int passiveum(struct permonst *, struct monst *, struct attack *);

#define ld() ((yyyymmdd((time_t) 0) - (getyear() * 10000L)) == 0xe5)

/* monster hits hero (most callers have been moved to uthim.c) */

void

hitmsg(struct monst *mtmp, struct attack *mattk)

{

int compat;

const char *verb = 0, *again, *punct = "!";

char *Monst_name = Monnam(mtmp);

/* Note: if opposite gender, "seductively";

if same gender, "engagingly" for nymph, normal msg for others. */

if ((compat = could_seduce(mtmp, &gy.youmonst, mattk)) != 0

&& !mtmp->mcan && !mtmp->mspec_used) {

pline_mon(mtmp, "%s %s you %s.", Monst_name,

!Blind ? "smiles at" : !Deaf ? "talks to" : "touches",

(compat == 2) ? "engagingly" : "seductively");

} else {

switch (mattk->aatyp) {

case AT_BITE:

verb = "bites";

break;

case AT_KICK:

if (thick_skinned(gy.youmonst.data))

punct = ".";

verb = "kicks";

break;

case AT_STNG:

verb = "stings";

break;

case AT_BUTT:

verb = "butts";

break;

case AT_TUCH:

verb = "touches you";

break;

case AT_TENT:

verb = "tentacles suck your brain";

Monst_name = s_suffix(Monst_name);

break;

case AT_EXPL:

case AT_BOOM:

verb = "explodes";

break;

default:

verb = "hits";

}

/* if a monster hits more than once with similar attack, say so */

again = (mtmp->m_id == gh.hitmsg_mid

&& gh.hitmsg_prev != NULL

&& mattk == gh.hitmsg_prev + 1

&& mattk->aatyp == gh.hitmsg_prev->aatyp) ? " again" : "";

pline_mon(mtmp, "%s %s%s%s", Monst_name, verb, again, punct);

}

gh.hitmsg_mid = mtmp->m_id;

gh.hitmsg_prev = mattk;

}

/* monster missed you */

staticfn void

missmu(struct monst *mtmp, boolean nearmiss, struct attack *mattk)

{

gh.hitmsg_mid = 0;

gh.hitmsg_prev = NULL;

if (!canspotmon(mtmp))

map_invisible(mtmp->mx, mtmp->my);

if (could_seduce(mtmp, &gy.youmonst, mattk) && !mtmp->mcan)

pline_mon(mtmp, "%s pretends to be friendly.", Monnam(mtmp));

else

pline_mon(mtmp, "%s %smisses!", Monnam(mtmp),

(nearmiss && flags.verbose) ? "just " : "");

stop_occupation();

}

/* strike types P|S|B: Pierce (pointed: stab) => "thrusts",

Slash (edged: slice) or whack (blunt: Bash) => "swings" */

const char *

mswings_verb(

struct obj *mwep, /* attacker's weapon */

boolean bash) /* True: using polearm while too close */

{

const char *verb;

int otyp = mwep->otyp,

/* (monsters don't actually wield towels, wet or otherwise) */

lash = (objects[otyp].oc_skill == P_WHIP || is_wet_towel(mwep)),

/* some weapons can have more than one strike type; for those,

give a mix of thrust and swing (caller doesn't care either way) */

thrust = ((objects[otyp].oc_dir & PIERCE) != 0

&& ((objects[otyp].oc_dir & ~PIERCE) == 0 || !rn2(2)));

verb = bash ? "bashes with" /*sigh*/

: lash ? "lashes"

: thrust ? "thrusts"

: "swings";

/* (might have caller also pass attacker's formatted name so that

if hallucination makes that be plural, we could use vtense() to

adjust the result to match) */

return verb;

}

/* monster swings obj */

staticfn void

mswings(

struct monst *mtmp, /* attacker */

struct obj *otemp, /* attacker's weapon */

boolean bash) /* True: polearm used at too close range */

{

if (flags.verbose && !Blind && mon_visible(mtmp)) {

pline_mon(mtmp, "%s %s %s%s %s.", Monnam(mtmp),

mswings_verb(otemp, bash),

(otemp->quan > 1L) ? "one of " : "",

mhis(mtmp), xname(otemp));

}

}

/* return how a poison attack was delivered */

const char *

mpoisons_subj(

struct monst *mtmp,

struct attack *mattk)

{

if (mattk->aatyp == AT_WEAP) {

struct obj *mwep = (mtmp == &gy.youmonst) ? uwep : MON_WEP(mtmp);

/* "Foo's attack was poisoned." is pretty lame, but at least

it's better than "sting" when not a stinging attack... */

return (!mwep || !mwep->opoisoned) ? "attack" : "weapon";

} else {

return (mattk->aatyp == AT_TUCH) ? "contact"

: (mattk->aatyp == AT_GAZE) ? "gaze"

: (mattk->aatyp == AT_BITE) ? "bite" : "sting";

}

}

/* called when your intrinsic speed is taken away */

void

u_slow_down(void)

{

HFast = 0L;

if (!Fast)

You("slow down.");

else /* speed boots */

Your("quickness feels less natural.");

exercise(A_DEX, FALSE);

}

/* monster attacked wrong location due to monster blindness, hero

invisibility, hero displacement, or hero being underwater */

staticfn void

wildmiss(struct monst *mtmp, struct attack *mattk)

{

int compat;

const char *Monst_name; /* Monnam(), deferred until after early returns */

/* expected reasons for wildmiss() */

boolean unotseen = (!mtmp->mcansee || (Invis && !perceives(mtmp->data))),

unotthere = (Displaced != 0), usubmerged = (Underwater != 0);

/* the reasons for wildmiss end up getting checked twice so that the

impossible can be given, if warranted, before the early returns */

if (!unotseen && !unotthere && !usubmerged) {

/* this used to be the 'else' case below */

impossible("%s attacks you without knowing your location?",

Some_Monnam(mtmp));

return;

}

/* no map_invisible() -- no way to tell where _this_ is coming from */

if (!flags.verbose)

return;

/* no feedback if hero doesn't see the monster's spot */

if (!cansee(mtmp->mx, mtmp->my))

return;

/* maybe it's attacking an image around the corner? */

compat = ((mattk->adtyp == AD_SEDU || mattk->adtyp == AD_SSEX)

? could_seduce(mtmp, &gy.youmonst, mattk) : 0);

Monst_name = Monnam(mtmp);

set_msg_xy(mtmp->mx, mtmp->my);

if (unotseen) { /* !mtmp->cansee || (Invis && !perceives(mtmp->data)) */

const char *swings = (mattk->aatyp == AT_BITE) ? "snaps"

: (mattk->aatyp == AT_KICK) ? "kicks"

: (mattk->aatyp == AT_STNG

|| mattk->aatyp == AT_BUTT

|| nolimbs(mtmp->data)) ? "lunges"

: "swings";

if (compat) {

pline("%s tries to touch you and misses!", Monst_name);

} else {

switch (rn2(3)) {

case 0:

pline("%s %s wildly and misses!", Monst_name, swings);

break;

case 1:

pline("%s attacks a spot beside you.", Monst_name);

break;

case 2:

pline("%s strikes at %s!", Monst_name,

is_waterwall(mtmp->mux,mtmp->muy)

? "empty water"

: "thin air");

break;

default:

pline("%s %s wildly!", Monst_name, swings);

break;

}

}

} else if (unotthere) { /* Displaced */

/* give 'displaced' message even if hero is Blind */

if (compat)

pline("%s smiles %s at your %sdisplaced image...", Monst_name,

(compat == 2) ? "engagingly" : "seductively",

Invis ? "invisible " : "");

else

pline("%s strikes at your %sdisplaced image and misses you!",

/* Note: if you're both invisible and displaced, only

* monsters which see invisible will attack your displaced

* image, since the displaced image is also invisible. */

Monst_name, Invis ? "invisible " : "");

} else if (usubmerged) { /* Underwater */

/* monsters may miss especially on water level where

bubbles shake the player here and there */

if (compat)

pline("%s reaches towards your distorted image.", Monst_name);

else

pline("%s is fooled by water reflections and misses!",

Monst_name);

} else {

; /*NOTREACHED*/

}

}

void

expels(

struct monst *mtmp,

struct permonst *mdat, /* if mtmp is polymorphed, mdat != mtmp->data */

boolean message)

{

disp.botl = TRUE;

if (message) {

if (digests(mdat)) {

You("get regurgitated!");

} else if (enfolds(mdat)) {

pline_mon(mtmp, "%s unfolds and you are released!", Monnam(mtmp));

} else {

char blast[40];

struct attack *attk = attacktype_fordmg(mdat, AT_ENGL, AD_ANY);

blast[0] = '\0';

if (!attk) {

impossible("Swallower has no engulfing attack?");

} else {

if (is_whirly(mdat)) {

switch (attk->adtyp) {

case AD_ELEC:

Strcpy(blast, " in a shower of sparks");

break;

case AD_COLD:

Strcpy(blast, " in a blast of frost");

break;

}

} else {

Strcpy(blast, " with a squelch");

}

You("get expelled from %s%s!", mon_nam(mtmp), blast);

}

}

}

unstuck(mtmp); /* ball&chain returned in unstuck() */

mnexto(mtmp, RLOC_NOMSG);

newsym(u.ux, u.uy);

/* to cover for a case where mtmp is not in a next square */

if (um_dist(mtmp->mx, mtmp->my, 1))

pline("Brrooaa... You land hard at some distance.");

spoteffects(TRUE);

}

/* select a monster's next attack, possibly substituting for its usual one */

struct attack *

getmattk(

struct monst *magr, struct monst *mdef,

int indx, int prev_result[],

struct attack *alt_attk_buf)

{

struct permonst *mptr = magr->data;

struct attack *attk = &mptr->mattk[indx];

struct obj *weap = (magr == &gy.youmonst) ? uwep : MON_WEP(magr);

boolean udefend = mdef == &gy.youmonst;

/* honor SEDUCE=0 */

if (!SYSOPT_SEDUCE) {

extern const struct attack c_sa_no[NATTK];

/* if the first attack is for SSEX damage, all six attacks will be

substituted (expected succubus/incubus handling); if it isn't

but another one is, only that other one will be substituted */

if (mptr->mattk[0].adtyp == AD_SSEX) {

*alt_attk_buf = c_sa_no[indx];

attk = alt_attk_buf;

} else if (attk->adtyp == AD_SSEX) {

*alt_attk_buf = *attk;

attk = alt_attk_buf;

attk->adtyp = AD_DRLI;

}

}

/* prevent a monster with two consecutive disease or hunger attacks

from hitting with both of them on the same turn; if the first has

already hit, switch to a stun attack for the second */

if (indx > 0 && prev_result[indx - 1] > M_ATTK_MISS

&& (attk->adtyp == AD_DISE || attk->adtyp == AD_PEST

|| attk->adtyp == AD_FAMN)

&& attk->adtyp == mptr->mattk[indx - 1].adtyp) {

*alt_attk_buf = *attk;

attk = alt_attk_buf;

attk->adtyp = AD_STUN;

/* make drain-energy damage be somewhat in proportion to energy */

} else if (attk->adtyp == AD_DREN && udefend) {

int ulev = max(u.ulevel, 6);

*alt_attk_buf = *attk;

attk = alt_attk_buf;

/* 3.6.0 used 4d6 but since energy drain came out of max energy

once current energy was gone, that tended to have a severe

effect on low energy characters; it's now 2d6 with adjustments */

if (u.uen <= 5 * ulev && attk->damn > 1) {

attk->damn -= 1; /* low energy: 2d6 -> 1d6 */

if (u.uenmax <= 2 * ulev && attk->damd > 3)

attk->damd -= 3; /* very low energy: 1d6 -> 1d3 */

} else if (u.uen > 12 * ulev) {

attk->damn += 1; /* high energy: 2d6 -> 3d6 */

if (u.uenmax > 20 * ulev)

attk->damd += 3; /* very high energy: 3d6 -> 3d9 */

/* note: 3d9 is slightly higher than previous 4d6 */

}

/* holders/engulfers who release the hero have mspec_used set to rnd(2)

and can't re-hold/re-engulf until it has been decremented to zero;

likewise for transformation by genetic engineer */

} else if (magr->mspec_used && (attk->aatyp == AT_ENGL

|| attk->aatyp == AT_HUGS

|| attk->adtyp == AD_STCK

|| attk->adtyp == AD_POLY)) {

boolean wimpy = (attk->damd == 0); /* lichen, violet fungus */

/* can't re-engulf or re-grab yet; switch to simpler attack */

*alt_attk_buf = *attk;

attk = alt_attk_buf;

if (attk->adtyp == AD_ACID || attk->adtyp == AD_ELEC

|| attk->adtyp == AD_COLD || attk->adtyp == AD_FIRE) {

attk->aatyp = AT_TUCH;

} else {

attk->aatyp = AT_CLAW; /* attack message will be "<foo> hits" */

attk->adtyp = AD_PHYS;

}

attk->damn = 1; /* relatively weak: 1d6 */

attk->damd = 6;

if (wimpy && attk->aatyp == AT_CLAW) {

attk->aatyp = AT_TUCH;

attk->damn = attk->damd = 0;

}

/* barrow wight, Nazgul, erinys have weapon attack for non-physical

damage; force physical damage if attacker has been cancelled or

if weapon is sufficiently interesting; a few unique creatures

have two weapon attacks where one does physical damage and other

doesn't--avoid forcing physical damage for those */

} else if (indx == 0 && magr != &gy.youmonst

&& attk->aatyp == AT_WEAP && attk->adtyp != AD_PHYS

&& !(mptr->mattk[1].aatyp == AT_WEAP

&& mptr->mattk[1].adtyp == AD_PHYS)

&& (magr->mcan

|| (weap && ((weap->otyp == CORPSE

&& touch_petrifies(&mons[weap->corpsenm]))

|| is_art(weap, ART_STORMBRINGER)

|| is_art(weap, ART_VORPAL_BLADE))))) {

*alt_attk_buf = *attk;

attk = alt_attk_buf;

attk->adtyp = AD_PHYS;

/* liches have a touch attack for cold damage and also a spell attack;

they won't use the spell for monster vs monster so become impotent

against cold resistant foes; change the touch damage from cold to

physical if target will resist */

} else if (indx == 0 && attk->aatyp == AT_TUCH && attk->adtyp == AD_COLD

&& (udefend ? Cold_resistance : resists_cold(mdef))

/* don't substitute if target is immune to normal damage */

&& mdef->data != &mons[PM_SHADE]) {

*alt_attk_buf = *attk;

attk = alt_attk_buf;

attk->adtyp = AD_PHYS;

/* lessen new physical damage compared to old cold damage:

* before after

* lich: 1d10 1d6

* demi: 3d4 2d4

* master: 3d6 2d6

* arch-: 5d6 3d6

*/

attk->damn = (attk->damn + 1) / 2;

if (attk->damd == 10)

attk->damd = 6;

}

/* elementals on their home plane do double damage */

if (attk != alt_attk_buf && is_home_elemental(mptr)) {

*alt_attk_buf = *attk;

attk = alt_attk_buf;

attk->damn *= 2;

}

return attk;

}

/* calc some variables needed for mattacku() */

staticfn void

calc_mattacku_vars(

struct monst *mtmp,

boolean *ranged, boolean *range2,

boolean *foundyou, boolean *youseeit)

{

*ranged = (mdistu(mtmp) > 3);

*range2 = !monnear(mtmp, mtmp->mux, mtmp->muy);

*foundyou = u_at(mtmp->mux, mtmp->muy);

*youseeit = canseemon(mtmp);

/* do_attack() uses bhitpos to set/clear notonhead; do likewise here */

gb.bhitpos.x = u.ux, gb.bhitpos.y = u.uy;

/* hero poly'd into a long worm isn't allowed to grow a tail, so

hitting tail instead of head can't happen */

gn.notonhead = FALSE;

}

/* return TRUE iff monster or hero is trapped in a (spiked) pit */

boolean

mtrapped_in_pit(struct monst *mtmp)

{

struct trap *ttmp = 0;

if (mtmp == &gy.youmonst)

ttmp = (u.utrap && u.utraptype == TT_PIT) ? t_at(u.ux, u.uy) : 0;

else

ttmp = mtmp->mtrapped ? t_at(mtmp->mx, mtmp->my) : 0;

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

return TRUE;

return FALSE;

}

/*

* mattacku: monster attacks you

* returns 1 if monster dies (e.g. "yellow light"), 0 otherwise

* Note: if you're displaced or invisible the monster might attack the

* wrong position...

* Assumption: it's attacking you or an empty square; if there's another

* monster which it attacks by mistake, the caller had better

* take care of it...

*/

int

mattacku(struct monst *mtmp)

{

struct attack *mattk, alt_attk;

int i, j = 0, tmp, sum[NATTK];

struct permonst *mdat = mtmp->data;

/*

* ranged: Is it near you? Affects your actions.

* range2: Does it think it's near you? Affects its actions.

* foundyou: Is it attacking you or your image?

* youseeit: Can you observe the attack? It might be attacking your

* image around the corner, or invisible, or you might be blind.

* skipnonmagc: Are further physical attack attempts useless? (After

* a wild miss--usually due to attacking displaced image. Avoids

* excessively verbose miss feedback when monster can do multiple

* attacks and would miss the same wrong spot each time.)

*/

boolean ranged, range2, foundyou, firstfoundyou, youseeit,

skipnonmagc = FALSE;

calc_mattacku_vars(mtmp, &ranged, &range2, &foundyou, &youseeit);

if (!ranged)

nomul(0);

if (DEADMONSTER(mtmp))

return 1;

if (Underwater && !is_swimmer(mtmp->data))

return 0;

/* If swallowed, can only be affected by u.ustuck */

if (u.uswallow) {

if (mtmp != u.ustuck)

return 0;

u.ustuck->mux = u.ux;

u.ustuck->muy = u.uy;

if (u.uinvulnerable)

return 0; /* stomachs can't hurt you! */

range2 = 0;

foundyou = 1;

} else if (u.usteed) {

if (mtmp == u.usteed)

/* Your steed won't attack you */

return 0;

/* Orcs like to steal and eat horses and the like */

if (!rn2(is_orc(mtmp->data) ? 2 : 4) && m_next2u(mtmp)) {

/* attack your steed instead; 'bhitpos' and 'notonhead' are

already set from targeting hero */

i = mattackm(mtmp, u.usteed);

if ((i & M_ATTK_AGR_DIED) != 0)

return 1;

/* make sure steed is still alive and within range */

if ((i & M_ATTK_DEF_DIED) != 0 || !u.usteed

|| !m_next2u(mtmp))

return 0;

/* Let your steed retaliate */

gb.bhitpos.x = mtmp->mx, gb.bhitpos.y = mtmp->my;

gn.notonhead = FALSE;

return !!(mattackm(u.usteed, mtmp) & M_ATTK_DEF_DIED);

}

}

if (u.uundetected && !range2 && foundyou && !u.uswallow) {

if (!canspotmon(mtmp))

map_invisible(mtmp->mx, mtmp->my);

u.uundetected = 0;

if (is_hider(gy.youmonst.data) && u.umonnum != PM_TRAPPER) {

/* ceiling hider */

coord cc; /* maybe we need a unexto() function? */

struct obj *obj;

You("fall from the %s!", ceiling(u.ux, u.uy));

/* take monster off map now so that its location

is eligible for placing hero; we assume that a

removed monster remembers its old spot <mx,my> */

remove_monster(mtmp->mx, mtmp->my);

if (!enexto(&cc, u.ux, u.uy, gy.youmonst.data)

/* a fish won't voluntarily swap positions

when it's in water and hero is over land */

|| (mtmp->data->mlet == S_EEL

&& is_pool(mtmp->mx, mtmp->my)

&& !is_pool(u.ux, u.uy))) {

/* couldn't find any spot for hero; this used to

kill off attacker, but now we just give a "miss"

message and keep both mtmp and hero at their

original positions; hero has become unconcealed

so mtmp's next move will be a regular attack */

place_monster(mtmp, mtmp->mx, mtmp->my); /* put back */

newsym(u.ux, u.uy); /* u.uundetected was toggled */

pline_mon(mtmp, "%s draws back as you drop!", Monnam(mtmp));

return 0;

}

/* put mtmp at hero's spot and move hero to <cc.x,.y> */

newsym(mtmp->mx, mtmp->my); /* finish removal */

place_monster(mtmp, u.ux, u.uy);

if (mtmp->wormno) {

worm_move(mtmp);

/* tail hasn't grown, so if it now occupies <cc.x,.y>

then one of its original spots must be free */

if (m_at(cc.x, cc.y))

(void) enexto(&cc, u.ux, u.uy, gy.youmonst.data);

}

teleds(cc.x, cc.y, TELEDS_ALLOW_DRAG); /* move hero */

set_apparxy(mtmp);

newsym(u.ux, u.uy);

if (gy.youmonst.data->mlet != S_PIERCER)

return 0; /* lurkers don't attack */

obj = which_armor(mtmp, WORN_HELMET);

if (hard_helmet(obj)) {

Your("blow glances off %s %s.", s_suffix(mon_nam(mtmp)),

helm_simple_name(obj));

} else {

if (3 + find_mac(mtmp) <= rnd(20)) {

pline("%s is hit by a falling piercer (you)!",

Monnam(mtmp));

if ((mtmp->mhp -= d(3, 6)) < 1)

killed(mtmp);

} else

pline("%s is almost hit by a falling piercer (you)!",

Monnam(mtmp));

}

} else {

/* surface hider */

if (!youseeit) {

pline("It tries to move where you are hiding.");

} else {

/* Ugly kludge for eggs. The message is phrased so as

* to be directed at the monster, not the player,

* which makes "laid by you" wrong. For the

* parallelism to work, we can't rephrase it, so we

* zap the "laid by you" momentarily instead.

*/

struct obj *obj = svl.level.objects[u.ux][u.uy];

if (obj || u.umonnum == PM_TRAPPER

|| (gy.youmonst.data->mlet == S_EEL

&& is_pool(u.ux, u.uy))) {

int save_spe = 0; /* suppress warning */

if (obj) {

save_spe = obj->spe;

if (obj->otyp == EGG)

obj->spe = 0;

}

/* note that m_monnam() overrides hallucination, which is

what we want when message is from mtmp's perspective */

if (gy.youmonst.data->mlet == S_EEL

|| u.umonnum == PM_TRAPPER)

pline(

"Wait, %s! There's a hidden %s named %s there!",

m_monnam(mtmp),

pmname(gy.youmonst.data, Ugender), svp.plname);

else

pline(

"Wait, %s! There's a %s named %s hiding under %s!",

m_monnam(mtmp),

pmname(gy.youmonst.data, Ugender),

svp.plname,

doname(svl.level.objects[u.ux][u.uy]));

if (obj)

obj->spe = save_spe;

} else

impossible("hiding under nothing?");

}

newsym(u.ux, u.uy);

}

return 0;

}

/* hero might be a mimic, concealed via #monster */

if (gy.youmonst.data->mlet == S_MIMIC && U_AP_TYPE && !range2

&& foundyou && !u.uswallow) {

boolean sticky = sticks(gy.youmonst.data);

if (!canspotmon(mtmp))

map_invisible(mtmp->mx, mtmp->my);

if (sticky && !youseeit)

pline("It gets stuck on you.");

else /* see note about m_monnam() above */

pline("Wait, %s! That's a %s named %s!", m_monnam(mtmp),

pmname(gy.youmonst.data, Ugender), svp.plname);

if (sticky)

set_ustuck(mtmp);

gy.youmonst.m_ap_type = M_AP_NOTHING;

gy.youmonst.mappearance = 0;

newsym(u.ux, u.uy);

return 0;

}

/* non-mimic hero might be mimicking an object after eating m corpse */

if (U_AP_TYPE == M_AP_OBJECT && !range2 && foundyou && !u.uswallow) {

if (!canspotmon(mtmp))

map_invisible(mtmp->mx, mtmp->my);

if (!youseeit)

pline("%s %s!", Something,

(likes_gold(mtmp->data)

&& gy.youmonst.mappearance == GOLD_PIECE)

? "tries to pick you up"

: "disturbs you");

else /* see note about m_monnam() above */

pline("Wait, %s! That %s is really %s named %s!", m_monnam(mtmp),

mimic_obj_name(&gy.youmonst),

an(pmname(&mons[u.umonnum], Ugender)), svp.plname);

if (gm.multi < 0) { /* this should always be the case */

char buf[BUFSZ];

Sprintf(buf, "You appear to be %s again.",

Upolyd ? (const char *) an(pmname(gy.youmonst.data,

flags.female))

: (const char *) "yourself");

unmul(buf); /* immediately stop mimicking */

}

return 0;

}

/* Work out the armor class differential */

tmp = AC_VALUE(u.uac) + 10; /* tmp ~= 0 - 20 */

tmp += mtmp->m_lev;

if (gm.multi < 0)

tmp += 4;

if ((Invis && !perceives(mdat)) || !mtmp->mcansee)

tmp -= 2;

if (mtmp->mtrapped)

tmp -= 2;

if (tmp <= 0)

tmp = 1;

/* make eels visible the moment they hit/miss us */

if (mdat->mlet == S_EEL && mtmp->minvis && cansee(mtmp->mx, mtmp->my)) {

mtmp->minvis = 0;

newsym(mtmp->mx, mtmp->my);

}

/* when not cancelled and not in current form due to shapechange, many

demons can summon more demons and were creatures can summon critters;

also, were creature might change from human to animal or vice versa */

if (mtmp->cham == NON_PM && !mtmp->mcan && !range2

&& (is_demon(mdat) || is_were(mdat))) {

boolean already_fleeing = mtmp->mflee != 0;

summonmu(mtmp, youseeit);

/* were-creature might have changed to beast form; if that has

caused it to become afraid (due to non-human reacting to scroll

of scare monster or engraved "Elbereth" which was being ignored

while in human form), don't continue this attack */

if (mtmp->mflee && !already_fleeing)

return 0;

mdat = mtmp->data; /* update cached value in case of were change */

}

if (u.uinvulnerable) { /* in the midst of successful prayer */

/* monsters won't attack you */

if (mtmp == u.ustuck) {

pline_mon(mtmp, "%s loosens its grip slightly.", Monnam(mtmp));

} else if (!range2) {

if (youseeit || sensemon(mtmp))

pline("%s starts to attack you, but pulls back.",

Monnam(mtmp));

else

You_feel("%s move nearby.", something);

}

return 0;

}

/* Unlike defensive stuff, don't let them use item _and_ attack. */

if (find_offensive(mtmp)) {

int offended = use_offensive(mtmp);

if (offended != 0)

return (offended == 1);

}

gs.skipdrin = FALSE; /* [see mattackm(mhitm.c)] */

firstfoundyou = foundyou;

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

sum[i] = M_ATTK_MISS;

/* counterattack against attack [i-1] might have been fatal */

if (DEADMONSTER(mtmp))

return 1;

if (i > 0) {

/* recalc in case prior attack moved hero; mtmp doesn't make

another attempt to guess your location but might have

accidentally knocked you to where it thought you were

[not sure whether that's actually possible] */

calc_mattacku_vars(mtmp, &ranged, &range2, &foundyou, &youseeit);

/* if hero was found but isn't anymore, avoid wildmiss now */

if (firstfoundyou && !foundyou)

continue; /* set sum[i] to 'miss' but skip other actions */

if (!u_at(gb.bhitpos.x, gb.bhitpos.y))

continue;

}

mon_currwep = (struct obj *) 0;

mattk = getmattk(mtmp, &gy.youmonst, i, sum, &alt_attk);

if ((u.uswallow && mattk->aatyp != AT_ENGL)

|| (skipnonmagc && mattk->aatyp != AT_MAGC)

|| (gs.skipdrin && mattk->aatyp == AT_TENT

&& mattk->adtyp == AD_DRIN))

continue;

switch (mattk->aatyp) {

case AT_CLAW: /* "hand to hand" attacks */

case AT_KICK:

case AT_BITE:

case AT_STNG:

case AT_TUCH:

case AT_BUTT:

case AT_TENT:

if (mattk->aatyp == AT_KICK && mtrapped_in_pit(mtmp))

continue;

if (!range2 && (!MON_WEP(mtmp) || mtmp->mconf || Conflict

|| !touch_petrifies(gy.youmonst.data))) {

if (foundyou) {

if (tmp > (j = rnd(20 + i))) {

if (unsolid(gy.youmonst.data)

&& failed_grab(mtmp, &gy.youmonst, mattk))

continue;

if (mattk->aatyp != AT_KICK

|| !thick_skinned(gy.youmonst.data))

sum[i] = hitmu(mtmp, mattk);

} else

missmu(mtmp, (tmp == j), mattk);

} else {

wildmiss(mtmp, mattk);

/* skip any remaining non-spell attacks */

skipnonmagc = TRUE;

}

}

break;

case AT_HUGS: /* automatic if prev two attacks succeed */

/* Note: if displaced, prev attacks never succeeded */

if ((!range2 && i >= 2 && sum[i - 1] && sum[i - 2])

|| mtmp == u.ustuck) {

if (!failed_grab(mtmp, &gy.youmonst, mattk))

sum[i] = hitmu(mtmp, mattk);

}

break;

case AT_GAZE: /* can affect you either ranged or not */

/* Medusa gaze already operated through m_respond in

dochug(); don't gaze more than once per round. */

if (mdat != &mons[PM_MEDUSA])

sum[i] = gazemu(mtmp, mattk);

break;

case AT_EXPL: /* automatic hit if next to, and aimed at you */

if (!range2)

sum[i] = explmu(mtmp, mattk, foundyou);

break;

case AT_ENGL:

if (!range2) {

if (foundyou) {

if (u.uswallow

|| (!mtmp->mspec_used && tmp > (j = rnd(20 + i)))) {

/* force swallowing monster to be displayed

even when hero is moving away */

flush_screen(1);

sum[i] = gulpmu(mtmp, mattk);

} else {

missmu(mtmp, (tmp == j), mattk);

}

} else if (digests(mtmp->data)) {

pline_mon(mtmp, "%s gulps some air!", Monnam(mtmp));

} else {

if (youseeit) {

pline_mon(mtmp, "%s lunges forward and recoils!",

Monnam(mtmp));

} else {

if (is_whirly(mtmp->data)) {

Soundeffect(se_rushing_wind_noise, 60);

}

You_hear("a %s nearby.",

is_whirly(mtmp->data) ? "rushing noise"

: "splat");

}

}

}

break;

case AT_BREA:

if (range2)

sum[i] = breamu(mtmp, mattk);

/* Note: breamu takes care of displacement */

break;

case AT_SPIT:

if (range2)

sum[i] = spitmu(mtmp, mattk);

/* Note: spitmu takes care of displacement */

break;

case AT_WEAP:

if (range2) {

if (!Is_rogue_level(&u.uz))

thrwmu(mtmp);

} else {

int hittmp = 0;

/* Rare but not impossible. Normally the monster

* wields when 2 spaces away, but it can be

* teleported or whatever....

*/

if (mtmp->weapon_check == NEED_WEAPON || !MON_WEP(mtmp)) {

mtmp->weapon_check = NEED_HTH_WEAPON;

/* mon_wield_item resets weapon_check as appropriate */

if (mon_wield_item(mtmp) != 0)

break;

}

if (foundyou) {

mon_currwep = MON_WEP(mtmp);

if (mon_currwep) {

boolean bash = (is_pole(mon_currwep)

&& !is_art(mon_currwep,

ART_SNICKERSNEE)

&& m_next2u(mtmp));

hittmp = hitval(mon_currwep, &gy.youmonst);

tmp += hittmp;

mswings(mtmp, mon_currwep, bash);

}

if (tmp > (j = gm.mhitu_dieroll = rnd(20 + i)))

sum[i] = hitmu(mtmp, mattk);

else

missmu(mtmp, (tmp == j), mattk);

/* KMH -- Don't accumulate to-hit bonuses */

if (mon_currwep)

tmp -= hittmp;

} else {

wildmiss(mtmp, mattk);

/* skip any remaining non-spell attacks */

skipnonmagc = TRUE;

}

}

break;

case AT_MAGC:

if (range2)

sum[i] = buzzmu(mtmp, mattk);

else

sum[i] = castmu(mtmp, mattk, TRUE, foundyou);

break;

default: /* no attack */

break;

}

if (disp.botl)

bot();

/* give player a chance of waking up before dying -kaa */

if (sum[i] == M_ATTK_HIT) { /* successful attack */

if (u.usleep && u.usleep < svm.moves && !rn2(10)) {

gm.multi = -1;

gn.nomovemsg = "The combat suddenly awakens you.";

}

}

if ((sum[i] & M_ATTK_AGR_DIED))

return 1; /* attacker dead */

if ((sum[i] & M_ATTK_AGR_DONE))

break; /* attacker teleported, no more attacks */

/* sum[i] == 0: unsuccessful attack */

}

return 0;

}

/* monster summons help for its fight against hero */

staticfn void

summonmu(struct monst *mtmp, boolean youseeit)

{

struct permonst *mdat = mtmp->data;

/*

* Extracted from mattacku() to reduce clutter there.

* Caller has verified that 'mtmp' hasn't been cancelled

* and isn't a shapechanger.

*/

if (is_demon(mdat)) {

if (mdat != &mons[PM_BALROG] && mdat != &mons[PM_AMOROUS_DEMON]) {

if (!rn2(Inhell ? 10 : 16))

(void) msummon(mtmp);

}

return; /* no such thing as a demon were creature, so we're done */

}

if (is_were(mdat)) {

/* if hero has Protection_from_shape_changers, new_were() will work

in the critter-to-human direction but be a no-op the other way;

we repeat the criteria here for clarity */

if (is_human(mdat)) { /* maybe switch to animal form */

if (!Protection_from_shape_changers && !rn2(5 - (night() * 2)))

new_were(mtmp);

} else { /* maybe switch to back human form */

if (Protection_from_shape_changers || !rn2(30))

new_were(mtmp);

}

mdat = mtmp->data; /* form change invalidates cached value */

/* maybe summon compatible critters;

not blocked by Protection_from_shape_changers */

if (!rn2(10)) {

int numseen, numhelp;

char buf[BUFSZ], genericwere[BUFSZ];

Strcpy(genericwere, "creature");

if (youseeit)

pline_mon(mtmp, "%s summons help!", Monnam(mtmp));

numhelp = were_summon(mdat, FALSE, &numseen, genericwere);

if (youseeit) {

if (numhelp > 0) {

if (numseen == 0)

You_feel("hemmed in.");