#include "hack.h"

#include "artifact.h"

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

STATIC_DCL boolean FDECL(u_slip_free, (struct monst *, struct attack *));

STATIC_DCL int FDECL(passiveum, (struct permonst *, struct monst *,

struct attack *));

STATIC_DCL void FDECL(mayberem, (struct monst *, const char *,

struct obj *, const char *));

STATIC_DCL boolean FDECL(diseasemu, (struct permonst *));

STATIC_DCL int FDECL(hitmu, (struct monst *, struct attack *));

STATIC_DCL int FDECL(gulpmu, (struct monst *, struct attack *));

STATIC_DCL int FDECL(explmu, (struct monst *, struct attack *, BOOLEAN_P));

STATIC_DCL void FDECL(missmu, (struct monst *, BOOLEAN_P, struct attack *));

STATIC_DCL void FDECL(mswings, (struct monst *, struct obj *));

STATIC_DCL void FDECL(wildmiss, (struct monst *, struct attack *));

STATIC_DCL void FDECL(hitmsg, (struct monst *, struct attack *));

static int dieroll;

STATIC_OVL void

hitmsg(mtmp, mattk)

struct monst *mtmp;

struct attack *mattk;

{

int compat;

const char *pfmt = 0;

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, &youmonst, mattk)) != 0

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

pline("%s %s you %s.", Monst_name,

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

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

} else {

switch (mattk->aatyp) {

case AT_BITE:

pfmt = "%s bites!";

break;

case AT_KICK:

pline("%s kicks%c", Monst_name,

thick_skinned(youmonst.data) ? '.' : '!');

break;

case AT_STNG:

pfmt = "%s stings!";

break;

case AT_BUTT:

pfmt = "%s butts!";

break;

case AT_TUCH:

pfmt = "%s touches you!";

break;

case AT_TENT:

pfmt = "%s tentacles suck you!";

Monst_name = s_suffix(Monst_name);

break;

case AT_EXPL:

case AT_BOOM:

pfmt = "%s explodes!";

break;

default:

pfmt = "%s hits!";

}

if (pfmt)

pline(pfmt, Monst_name);

}

}

STATIC_OVL void

missmu(mtmp, nearmiss, mattk)

struct monst *mtmp;

boolean nearmiss;

struct attack *mattk;

{

if (!canspotmon(mtmp))

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

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

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

else

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

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

stop_occupation();

}

STATIC_OVL void

mswings(mtmp, otemp)

struct monst *mtmp;

struct obj *otemp;

{

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

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

(objects[otemp->otyp].oc_dir & PIERCE) ? "thrusts" : "swings",

(otemp->quan > 1L) ? "one of " : "", mhis(mtmp), xname(otemp));

}

}

const char *

mpoisons_subj(mtmp, mattk)

struct monst *mtmp;

struct attack *mattk;

{

if (mattk->aatyp == AT_WEAP) {

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

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

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

} else {

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

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

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

}

}

u_slow_down()

{

HFast = 0L;

if (!Fast)

You("slow down.");

else /* speed boots */

Your("quickness feels less natural.");

exercise(A_DEX, FALSE);

}

STATIC_OVL void

wildmiss(mtmp, mattk)

struct monst *mtmp;

struct attack *mattk;

{

int compat;

const char *Monst_name; /* Monnam(mtmp) */

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

if (!flags.verbose)

return;

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, &youmonst, mattk) : 0);

Monst_name = Monnam(mtmp);

if (!mtmp->mcansee || (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,

(levl[mtmp->mux][mtmp->muy].typ == WATER)

? "empty water"

: "thin air");

break;

default:

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

break;

}

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

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

} else if (Underwater) {

/* monsters may miss especially on water level where

if (compat)

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

else

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

Monst_name);

} else

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

Monst_name);

}

expels(mtmp, mdat, message)

struct monst *mtmp;

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

boolean message;

{

if (message) {

if (is_animal(mdat)) {

You("get regurgitated!");

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

newsym(u.ux, u.uy);

spoteffects(TRUE);

/* 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.");

}

struct attack *

getmattk(magr, mdef, indx, prev_result, alt_attk_buf)

struct monst *magr, *mdef;

int indx, prev_result[];

struct attack *alt_attk_buf;

{

struct permonst *mptr = magr->data;

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

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

/* honor SEDUCE=0 */

if (!SYSOPT_SEDUCE) {

extern const struct attack sa_no[NATTK];

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

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

*alt_attk_buf = 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

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

&& (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 && mdef == &youmonst) {

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

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

}

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

/* can't re-engulf 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;

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

} else if (indx == 0 && magr != &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]))

|| weap->oartifact == ART_STORMBRINGER

|| weap->oartifact == ART_VORPAL_BLADE)))) {

*alt_attk_buf = *attk;

attk = alt_attk_buf;

attk->adtyp = AD_PHYS;

}

return attk;

}

mattacku(mtmp)

register struct monst *mtmp;

{

struct attack *mattk, alt_attk;

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

struct permonst *mdat = mtmp->data;

boolean ranged = (distu(mtmp->mx, mtmp->my) > 3);

/* Is it near you? Affects your actions */

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

/* Does it think it's near you? Affects its actions */

boolean foundyou = (mtmp->mux == u.ux && mtmp->muy == u.uy);

/* Is it attacking you or your image? */

boolean youseeit = canseemon(mtmp);

/* Might be attacking your image around the corner, or

boolean skipnonmagc = FALSE;

/* Are further physical attack attempts useless? */

if (!ranged)

nomul(0);

if (DEADMONSTER(mtmp) || (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;

range2 = 0;

foundyou = 1;

if (u.uinvulnerable)

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

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

&& distu(mtmp->mx, mtmp->my) <= 2) {

/* Attack your steed instead */

i = mattackm(mtmp, u.usteed);

if ((i & MM_AGR_DIED))

return 1;

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

if ((i & MM_DEF_DIED) || !u.usteed

|| distu(mtmp->mx, mtmp->my) > 2)

return 0;

/* Let your steed retaliate */

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

}

}

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

if (!canspotmon(mtmp))

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

u.uundetected = 0;

if (is_hider(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

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

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

/* a fish won't voluntarily swap positions

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

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

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

pline("%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>

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

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

}

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

set_apparxy(mtmp);

newsym(u.ux, u.uy);

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

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

obj = which_armor(mtmp, WORN_HELMET);

if (obj && is_metallic(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

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

if (obj || u.umonnum == PM_TRAPPER

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

if (youmonst.data->mlet == S_EEL

|| u.umonnum == PM_TRAPPER)

pline(

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

m_monnam(mtmp), youmonst.data->mname, plname);

else

pline(

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

m_monnam(mtmp), youmonst.data->mname, plname,

doname(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 (youmonst.data->mlet == S_MIMIC && U_AP_TYPE && !range2

&& foundyou && !u.uswallow) {

boolean sticky = sticks(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),

youmonst.data->mname, plname);

if (sticky)

u.ustuck = mtmp;

youmonst.m_ap_type = M_AP_NOTHING;

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)

&& 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(&youmonst), an(mons[u.umonnum].mname),

plname);

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

char buf[BUFSZ];

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

Upolyd ? (const char *) an(youmonst.data->mname)

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

}

/* Special demon handling code */

if ((mtmp->cham == NON_PM) && is_demon(mdat) && !range2

&& mtmp->data != &mons[PM_BALROG] && mtmp->data != &mons[PM_SUCCUBUS]

&& mtmp->data != &mons[PM_INCUBUS])

if (!mtmp->mcan && !rn2(13))

(void) msummon(mtmp);

/* Special lycanthrope handling code */

if ((mtmp->cham == NON_PM) && is_were(mdat) && !range2) {

if (is_human(mdat)) {

if (!rn2(5 - (night() * 2)) && !mtmp->mcan)

new_were(mtmp);

} else if (!rn2(30) && !mtmp->mcan)

new_were(mtmp);

mdat = mtmp->data;

if (!rn2(10) && !mtmp->mcan) {

int numseen, numhelp;

char buf[BUFSZ], genericwere[BUFSZ];

Strcpy(genericwere, "creature");

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

if (youseeit) {

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

if (numhelp > 0) {

if (numseen == 0)

You_feel("hemmed in.");

} else

pline("But none comes.");

} else {

const char *from_nowhere;

if (!Deaf) {

pline("%s %s!", Something, makeplural(growl_sound(mtmp)));

from_nowhere = "";

} else

from_nowhere = " from nowhere";

if (numhelp > 0) {

if (numseen < 1)

You_feel("hemmed in.");

else {

if (numseen == 1)

Sprintf(buf, "%s appears", an(genericwere));

else

Sprintf(buf, "%s appear",

makeplural(genericwere));

pline("%s%s!", upstart(buf), from_nowhere);

}

} /* else no help came; but you didn't know it tried */

}

}

}

if (u.uinvulnerable) {

/* monsters won't attack you */

if (mtmp == u.ustuck) {

pline("%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 foo = use_offensive(mtmp);

if (foo != 0)

return (foo == 1);

}

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

sum[i] = 0;

mon_currwep = (struct obj *)0;

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

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

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

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 (!range2 && (!MON_WEP(mtmp) || mtmp->mconf || Conflict

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

if (foundyou) {

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

if (mattk->aatyp != AT_KICK

|| !thick_skinned(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)

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

break;

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

/* Medusa gaze already operated through m_respond in

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

flush_screen(1);

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

} else {

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

}

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

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

} else {

if (youseeit)

pline("%s lunges forward and recoils!", Monnam(mtmp));

else

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

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

hittmp = hitval(mon_currwep, &youmonst);

tmp += hittmp;

mswings(mtmp, mon_currwep);

}

if (tmp > (j = 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 (context.botl)

bot();

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

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

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

multi = -1;

nomovemsg = "The combat suddenly awakens you.";

}

}

if (sum[i] == 2)

return 1; /* attacker dead */

if (sum[i] == 3)

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

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

}

return 0;

}

STATIC_OVL boolean

diseasemu(mdat)

struct permonst *mdat;

{

if (Sick_resistance) {

You_feel("a slight illness.");

return FALSE;

} else {

make_sick(Sick ? Sick / 3L + 1L : (long) rn1(ACURR(A_CON), 20),

mdat->mname, TRUE, SICK_NONVOMITABLE);

return TRUE;

}

}

STATIC_OVL boolean

u_slip_free(mtmp, mattk)

struct monst *mtmp;

struct attack *mattk;

{

struct obj *obj = (uarmc ? uarmc : uarm);

if (!obj)

obj = uarmu;

if (mattk->adtyp == AD_DRIN)

obj = uarmh;

/* if your cloak/armor is greased, monster slips off; this

if (obj && (obj->greased || obj->otyp == OILSKIN_CLOAK)

&& (!obj->cursed || rn2(3))) {

pline("%s %s your %s %s!", Monnam(mtmp),

(mattk->adtyp == AD_WRAP) ? "slips off of"

: "grabs you, but cannot hold onto",

obj->greased ? "greased" : "slippery",

/* avoid "slippery slippery cloak"

(obj->greased || objects[obj->otyp].oc_name_known)

? xname(obj)

: cloak_simple_name(obj));

if (obj->greased && !rn2(2)) {

pline_The("grease wears off.");

obj->greased = 0;

update_inventory();

}

return TRUE;

}

return FALSE;

}

magic_negation(mon)

struct monst *mon;

{

struct obj *o;

long wearmask;

int armpro, mc = 0;

boolean is_you = (mon == &youmonst),

gotprot = is_you ? (EProtection != 0L)

/* high priests have innate protection */

: (mon->data == &mons[PM_HIGH_PRIEST]);

for (o = is_you ? invent : mon->minvent; o; o = o->nobj) {

/* a_can field is only applicable for armor (which must be worn) */

if ((o->owornmask & W_ARMOR) != 0L) {

armpro = objects[o->otyp].a_can;

if (armpro > mc)

mc = armpro;

}

/* if we've already confirmed Protection, skip additional checks */

if (is_you || gotprot)

continue;

/* omit W_SWAPWEP+W_QUIVER; W_ART+W_ARTI handled by protects() */

wearmask = W_ARMOR | W_ACCESSORY;

if (o->oclass == WEAPON_CLASS || is_weptool(o))

wearmask |= W_WEP;

if (protects(o, ((o->owornmask & wearmask) != 0L) ? TRUE : FALSE))

gotprot = TRUE;

}

if (gotprot) {

/* extrinsic Protection increases mc by 1 */

if (mc < 3)

mc += 1;

} else if (mc < 1) {

/* intrinsic Protection is weaker (play balance; obtaining divine

if ((is_you && ((HProtection && u.ublessed > 0) || u.uspellprot))

/* aligned priests and angels have innate intrinsic Protection */

|| (mon->data == &mons[PM_ALIGNED_PRIEST] || is_minion(mon->data)))

mc = 1;

}

return mc;

}

STATIC_OVL int

hitmu(mtmp, mattk)

register struct monst *mtmp;

register struct attack *mattk;

{

struct permonst *mdat = mtmp->data;

int uncancelled, ptmp;

int dmg, armpro, permdmg, tmphp;

char buf[BUFSZ];

struct permonst *olduasmon = youmonst.data;

int res;

if (!canspotmon(mtmp))

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

/* If the monster is undetected & hits you, you should know where

if (mtmp->mundetected && (hides_under(mdat) || mdat->mlet == S_EEL)) {

mtmp->mundetected = 0;

if (!(Blind ? Blind_telepat : Unblind_telepat)) {

struct obj *obj;

const char *what;

if ((obj = level.objects[mtmp->mx][mtmp->my]) != 0) {

if (Blind && !obj->dknown)

what = something;

else if (is_pool(mtmp->mx, mtmp->my) && !Underwater)

what = "the water";

else

what = doname(obj);

pline("%s was hidden under %s!", Amonnam(mtmp), what);

}

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

}

}

/* First determine the base damage done */

dmg = d((int) mattk->damn, (int) mattk->damd);

if ((is_undead(mdat) || is_vampshifter(mtmp)) && midnight())

dmg += d((int) mattk->damn, (int) mattk->damd); /* extra damage */

/* Next a cancellation factor.

armpro = magic_negation(&youmonst);

uncancelled = !mtmp->mcan && (rn2(10) >= 3 * armpro);

permdmg = 0;

/* Now, adjust damages via resistances or specific attacks */

switch (mattk->adtyp) {

case AD_PHYS:

if (mattk->aatyp == AT_HUGS && !sticks(youmonst.data)) {

if (!u.ustuck && rn2(2)) {

if (u_slip_free(mtmp, mattk)) {

dmg = 0;

} else {

u.ustuck = mtmp;

pline("%s grabs you!", Monnam(mtmp));

}

} else if (u.ustuck == mtmp) {

exercise(A_STR, FALSE);

You("are being %s.", (mtmp->data == &mons[PM_ROPE_GOLEM])

? "choked"

: "crushed");

}

} else { /* hand to hand weapon */

struct obj *otmp = mon_currwep;

if (mattk->aatyp == AT_WEAP && otmp) {

struct obj *marmg;

int tmp;

if (otmp->otyp == CORPSE

&& touch_petrifies(&mons[otmp->corpsenm])) {

dmg = 1;

pline("%s hits you with the %s corpse.", Monnam(mtmp),

mons[otmp->corpsenm].mname);

if (!Stoned)