#include "hack.h"

static const char

*const plusattr[] = { "strong", "smart", "wise",

"agile", "tough", "charismatic" },

*const minusattr[] = { "weak", "stupid",

"foolish", "clumsy",

"fragile", "repulsive" };

extern const char *const attrname[6];

const char

*const attrname[] = { "strength", "intelligence", "wisdom",

"dexterity", "constitution", "charisma" };

static const struct innate {

} arc_abil[] = { { 1, &(HSearching), "", "" },

{ 5, &(HStealth), "stealthy", "" },

{ 10, &(HFast), "quick", "slow" },

{ 0, 0, 0, 0 } },

bar_abil[] = { { 1, &(HPoison_resistance), "", "" },

{ 7, &(HFast), "quick", "slow" },

{ 15, &(HStealth), "stealthy", "" },

{ 0, 0, 0, 0 } },

cav_abil[] = { { 7, &(HFast), "quick", "slow" },

{ 15, &(HWarning), "sensitive", "" },

{ 0, 0, 0, 0 } },

hea_abil[] = { { 1, &(HPoison_resistance), "", "" },

{ 15, &(HWarning), "sensitive", "" },

{ 0, 0, 0, 0 } },

kni_abil[] = { { 7, &(HFast), "quick", "slow" }, { 0, 0, 0, 0 } },

mon_abil[] = { { 1, &(HFast), "", "" },

{ 1, &(HSleep_resistance), "", "" },

{ 1, &(HSee_invisible), "", "" },

{ 3, &(HPoison_resistance), "healthy", "" },

{ 5, &(HStealth), "stealthy", "" },

{ 7, &(HWarning), "sensitive", "" },

{ 9, &(HSearching), "perceptive", "unaware" },

{ 11, &(HFire_resistance), "cool", "warmer" },

{ 13, &(HCold_resistance), "warm", "cooler" },

{ 15, &(HShock_resistance), "insulated", "conductive" },

{ 17, &(HTeleport_control), "controlled", "uncontrolled" },

{ 0, 0, 0, 0 } },

pri_abil[] = { { 15, &(HWarning), "sensitive", "" },

{ 20, &(HFire_resistance), "cool", "warmer" },

{ 0, 0, 0, 0 } },

ran_abil[] = { { 1, &(HSearching), "", "" },

{ 7, &(HStealth), "stealthy", "" },

{ 15, &(HSee_invisible), "", "" },

{ 0, 0, 0, 0 } },

rog_abil[] = { { 1, &(HStealth), "", "" },

{ 10, &(HSearching), "perceptive", "" },

{ 0, 0, 0, 0 } },

sam_abil[] = { { 1, &(HFast), "", "" },

{ 15, &(HStealth), "stealthy", "" },

{ 0, 0, 0, 0 } },

tou_abil[] = { { 10, &(HSearching), "perceptive", "" },

{ 20, &(HPoison_resistance), "hardy", "" },

{ 0, 0, 0, 0 } },

val_abil[] = { { 1, &(HCold_resistance), "", "" },

{ 3, &(HStealth), "stealthy", "" },

{ 7, &(HFast), "quick", "slow" },

{ 0, 0, 0, 0 } },

wiz_abil[] = { { 15, &(HWarning), "sensitive", "" },

{ 17, &(HTeleport_control), "controlled", "uncontrolled" },

{ 0, 0, 0, 0 } },

/* Intrinsics conferred by race */

dwa_abil[] = { { 1, &HInfravision, "", "" },

{ 0, 0, 0, 0 } },

elf_abil[] = { { 1, &HInfravision, "", "" },

{ 4, &HSleep_resistance, "awake", "tired" },

{ 0, 0, 0, 0 } },

gno_abil[] = { { 1, &HInfravision, "", "" },

{ 0, 0, 0, 0 } },

orc_abil[] = { { 1, &HInfravision, "", "" },

{ 1, &HPoison_resistance, "", "" },

{ 0, 0, 0, 0 } },

hum_abil[] = { { 0, 0, 0, 0 } };

staticfn void exerper(void);

staticfn int rnd_attr(void);

staticfn int init_attr_role_redist(int, boolean);

staticfn void postadjabil(long *) NONNULLARG1;

staticfn const struct innate *role_abil(int);

staticfn const struct innate *check_innate_abil(long *, long);

staticfn int innately(long *);

adjattrib(

int ndx, /* which characteristic */

int incr, /* amount of change */

int msgflg) /* positive => no message, zero => message, and */

{ /* negative => conditional (msg if change made) */

int old_acurr, old_abase, old_amax, decr;

boolean abonflg;

const char *attrstr;

if (Fixed_abil || !incr)

return FALSE;

if ((ndx == A_INT || ndx == A_WIS) && uarmh && uarmh->otyp == DUNCE_CAP) {

if (msgflg == 0)

Your("cap constricts briefly, then relaxes again.");

return FALSE;

}

old_acurr = ACURR(ndx);

old_abase = ABASE(ndx);

old_amax = AMAX(ndx);

ABASE(ndx) += incr; /* when incr is negative, this reduces ABASE() */

if (incr > 0) {

if (ABASE(ndx) > AMAX(ndx)) {

AMAX(ndx) = ABASE(ndx);

if (AMAX(ndx) > ATTRMAX(ndx))

ABASE(ndx) = AMAX(ndx) = ATTRMAX(ndx);

}

attrstr = plusattr[ndx];

abonflg = (ABON(ndx) < 0);

} else { /* incr is negative */

if (ABASE(ndx) < ATTRMIN(ndx)) {

/*

decr = rn2(ATTRMIN(ndx) - ABASE(ndx) + 1);

ABASE(ndx) = ATTRMIN(ndx);

AMAX(ndx) -= decr;

if (AMAX(ndx) < ATTRMIN(ndx))

AMAX(ndx) = ATTRMIN(ndx);

}

attrstr = minusattr[ndx];

abonflg = (ABON(ndx) > 0);

}

if (ACURR(ndx) == old_acurr) {

if (msgflg == 0 && flags.verbose) {

if (ABASE(ndx) == old_abase && AMAX(ndx) == old_amax) {

pline("You're %s as %s as you can get.",

abonflg ? "currently" : "already", attrstr);

} else {

/* current stayed the same but base value changed, or

Your("innate %s has %s.", attrname[ndx],

(incr > 0) ? "improved" : "declined");

}

}

return FALSE;

}

/* Any successful change also resets abuse / exercise level */

AEXE(ndx) = 0;

disp.botl = TRUE;

if (msgflg <= 0)

You_feel("%s%s!", (incr > 1 || incr < -1) ? "very " : "", attrstr);

if (program_state.in_moveloop && (ndx == A_STR || ndx == A_CON))

encumber_msg();

return TRUE;

}

gainstr(struct obj *otmp, int incr, boolean givemsg)

{

int num = incr;

if (!num) {

if (ABASE(A_STR) < 18)

num = (rn2(4) ? 1 : rnd(6));

else if (ABASE(A_STR) < STR18(85))

num = rnd(10);

else

num = 1;

}

(void) adjattrib(A_STR, (otmp && otmp->cursed) ? -num : num,

givemsg ? -1 : 1);

}

losestr(int num, const char *knam, schar k_format)

{

int uhpmin = minuhpmax(1), olduhpmax = u.uhpmax;

int ustr = ABASE(A_STR) - num, amt, dmg;

boolean waspolyd = Upolyd;

if (num <= 0 || ABASE(A_STR) < ATTRMIN(A_STR)) {

impossible("losestr: %d - %d", ABASE(A_STR), num);

return;

}

dmg = 0;

while (ustr < ATTRMIN(A_STR)) {

++ustr;

--num;

amt = rn1(4, 3); /* (0..(4-1))+3 => 3..6; used to use flat 6 here */

dmg += amt;

}

if (dmg) {

/* in case damage is fatal and caller didn't supply killer reason */

if (!knam || !*knam) {

knam = "terminal frailty";

k_format = KILLED_BY;

}

losehp(dmg, knam, k_format);

if (Upolyd) {

/* when still poly'd, reduce you-as-monst maxHP; never below 1 */

setuhpmax(max(u.mhmax - dmg, 1), FALSE); /* acts as setmhmax() */

} else if (!waspolyd) {

/* not polymorphed now and didn't rehumanize when taking damage;

if (u.uhpmax > uhpmin)

setuhpmax(max(u.uhpmax - dmg, uhpmin), FALSE);

}

disp.botl = TRUE;

}

#if 0 /* only possible if uhpmax was already less than uhpmin */

if (!Upolyd && u.uhpmax < uhpmin) {

setuhpmax(min(olduhpmax, uhpmin), FALSE);

if (!Drain_resistance)

losexp(NULL); /* won't be fatal when no 'drainer' is supplied */

}

nhUse(olduhpmax);

/* 'num' could have been reduced to 0 in the minimum strength loop;

if (num > 0 && (Upolyd || !waspolyd))

(void) adjattrib(A_STR, -num, 1);

}

poison_strdmg(int strloss, int dmg, const char *knam, schar k_format)

{

losestr(strloss, knam, k_format);

losehp(dmg, knam, k_format);

}

static const struct poison_effect_message {

void (*delivery_func)(const char *, ...);

const char *effect_msg;

} poiseff[] = {

{ You_feel, "weaker" }, /* A_STR */

{ Your, "brain is on fire" }, /* A_INT */

{ Your, "judgement is impaired" }, /* A_WIS */

{ Your, "muscles won't obey you" }, /* A_DEX */

{ You_feel, "very sick" }, /* A_CON */

{ You, "break out in hives" } /* A_CHA */

};

poisontell(int typ, /* which attribute */

boolean exclaim) /* emphasis */

{

void (*func)(const char *, ...) = poiseff[typ].delivery_func;

const char *msg_txt = poiseff[typ].effect_msg;

/*

if (typ == A_STR && ACURR(A_STR) == STR19(25))

msg_txt = "innately weaker";

else if (typ == A_CON && ACURR(A_CON) == 25)

msg_txt = "sick inside";

(*func)("%s%c", msg_txt, exclaim ? '!' : '.');

}

poisoned(

boolean thrown_weapon) /* thrown weapons are less deadly */

{

int i, loss, kprefix = KILLED_BY_AN;

boolean blast = !strcmp(reason, "blast");

/* inform player about being poisoned unless that's already been done;

if (!blast && !strstri(reason, "poison")) {

boolean plural = (reason[strlen(reason) - 1] == 's') ? 1 : 0;

/* avoid "The" Orcus's sting was poisoned... */

pline("%s%s %s poisoned!",

isupper((uchar) *reason) ? "" : "The ", reason,

plural ? "were" : "was");

}

if (Poison_resistance) {

if (blast)

shieldeff(u.ux, u.uy);

pline_The("poison doesn't seem to affect you.");

return;

}

/* suppress killer prefix if it already has one */

i = name_to_mon(pkiller, (int *) 0);

if (ismnum(i) && (mons[i].geno & G_UNIQ)) {

kprefix = KILLED_BY;

if (!type_is_pname(&mons[i]))

pkiller = the(pkiller);

} else if (!strncmpi(pkiller, "the ", 4) || !strncmpi(pkiller, "an ", 3)

|| !strncmpi(pkiller, "a ", 2)) {

/*[ does this need a plural check too? ]*/

kprefix = KILLED_BY;

}

/*

i = !fatal ? 1 : rn2(fatal + (thrown_weapon ? 20 : 0));

if (i == 0 && typ != A_CHA) {

/* sometimes survivable instant kill */

loss = 6 + d(4, 6); /* 6 + 4d6 => 10..34 */

if (u.uhp <= loss) {

u.uhp = -1;

disp.botl = TRUE;

pline_The("poison was deadly...");

} else {

/* survived, but with severe reaction */

int olduhp = u.uhp,

newuhpmax = u.uhpmax - (loss / 2);

setuhpmax(max(newuhpmax, minuhpmax(3)), TRUE); /*True: see FIXME*/

loss = adjuhploss(loss, olduhp);

losehp(loss, pkiller, kprefix); /* poison damage */

if (adjattrib(A_CON, (typ != A_CON) ? -1 : -3, TRUE))

poisontell(A_CON, TRUE);

if (typ != A_CON && adjattrib(typ, -3, 1))

poisontell(typ, TRUE);

}

} else if (i > 5) {

boolean cloud = !strcmp(reason, "gas cloud");

/* HP damage; more likely--but less severe--with missiles */

loss = thrown_weapon ? rnd(6) : rn1(10, 6);

if ((blast || cloud) && Half_gas_damage) /* worn towel */

loss = (loss + 1) / 2;

losehp(loss, pkiller, kprefix); /* poison damage */

} else {

/* attribute loss; if typ is A_STR, reduction in current and

loss = (thrown_weapon || !fatal) ? 1 : d(2, 2); /* was rn1(3,3) */

/* check that a stat change was made */

if (adjattrib(typ, -loss, 1))

poisontell(typ, TRUE);

}

if (u.uhp < 1) {

svk.killer.format = kprefix;

Strcpy(svk.killer.name, pkiller);

/* "Poisoned by a poisoned ___" is redundant */

done(strstri(pkiller, "poison") ? DIED : POISONING);

}

encumber_msg();

}

change_luck(schar n)

{

u.uluck += n;

if (u.uluck < 0 && u.uluck < LUCKMIN)

u.uluck = LUCKMIN;

if (u.uluck > 0 && u.uluck > LUCKMAX)

u.uluck = LUCKMAX;

}

stone_luck(boolean include_uncursed)

{

struct obj *otmp;

long bonchance = 0;

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

if (confers_luck(otmp)) {

if (otmp->cursed)

bonchance -= otmp->quan;

else if (otmp->blessed || include_uncursed)

bonchance += otmp->quan;

}

return sgn((int) bonchance);

}

set_moreluck(void)

{

int luckbon = stone_luck(TRUE);

if (!luckbon && !carrying(LUCKSTONE))

u.moreluck = 0;

else if (luckbon >= 0)

u.moreluck = LUCKADD;

else

u.moreluck = -LUCKADD;

}

restore_attrib(void)

{

int i, equilibrium;;

/*

for (i = 0; i < A_MAX; i++) { /* all temporary losses/gains */

equilibrium = ((i == A_STR && u.uhs >= WEAK)

|| (i == A_DEX && Wounded_legs)) ? -1 : 0;

if (ATEMP(i) != equilibrium && ATIME(i) != 0) {

if (!(--(ATIME(i)))) { /* countdown for change */

ATEMP(i) += (ATEMP(i) > 0) ? -1 : 1;

disp.botl = TRUE;

if (ATEMP(i)) /* reset timer */

ATIME(i) = 100 / ACURR(A_CON);

}

}

}

if (disp.botl)

encumber_msg();

}

#define AVAL 50 /* tune value for exercise gains */

exercise(int i, boolean inc_or_dec)

{

debugpline0("Exercise:");

if (i == A_INT || i == A_CHA)

return; /* can't exercise these */

/* no physical exercise while polymorphed; the body's temporary */

if (Upolyd && i != A_WIS)

return;

if (abs(AEXE(i)) < AVAL) {

/*

AEXE(i) += (inc_or_dec) ? (rn2(19) > ACURR(i)) : -rn2(2);

debugpline3("%s, %s AEXE = %d",

(i == A_STR) ? "Str" : (i == A_WIS) ? "Wis" : (i == A_DEX)

? "Dex"

: "Con",

(inc_or_dec) ? "inc" : "dec", AEXE(i));

}

if (svm.moves > 0 && (i == A_STR || i == A_CON))

encumber_msg();

}

staticfn void

exerper(void)

{

if (!(svm.moves % 10)) {

/* Hunger Checks */

int hs = (u.uhunger > 1000) ? SATIATED

: (u.uhunger > 150) ? NOT_HUNGRY

: (u.uhunger > 50) ? HUNGRY

: (u.uhunger > 0) ? WEAK

: FAINTING;

debugpline0("exerper: Hunger checks");

switch (hs) {

case SATIATED:

exercise(A_DEX, FALSE);

if (Role_if(PM_MONK))

exercise(A_WIS, FALSE);

break;

case NOT_HUNGRY:

exercise(A_CON, TRUE);

break;

case WEAK:

exercise(A_STR, FALSE);

if (Role_if(PM_MONK)) /* fasting */

exercise(A_WIS, TRUE);

break;

case FAINTING:

case FAINTED:

exercise(A_CON, FALSE);

break;

}

/* Encumbrance Checks */

debugpline0("exerper: Encumber checks");

switch (near_capacity()) {

case MOD_ENCUMBER:

exercise(A_STR, TRUE);

break;

case HVY_ENCUMBER:

exercise(A_STR, TRUE);

exercise(A_DEX, FALSE);

break;

case EXT_ENCUMBER:

exercise(A_DEX, FALSE);

exercise(A_CON, FALSE);

break;

}

}

/* status checks */

if (!(svm.moves % 5)) {

debugpline0("exerper: Status checks");

if ((HClairvoyant & (INTRINSIC | TIMEOUT)) && !BClairvoyant)

exercise(A_WIS, TRUE);

if (HRegeneration)

exercise(A_STR, TRUE);

if (Sick || Vomiting)

exercise(A_CON, FALSE);

if (Confusion || Hallucination)

exercise(A_WIS, FALSE);

if ((Wounded_legs && !u.usteed) || Fumbling || HStun)

exercise(A_DEX, FALSE);

}

}

static NEARDATA const char *const exertext[A_MAX][2] = {

{ "exercising diligently", "exercising properly" }, /* Str */

{ 0, 0 }, /* Int */

{ "very observant", "paying attention" }, /* Wis */

{ "working on your reflexes", "working on reflexes lately" }, /* Dex */

{ "leading a healthy life-style", "watching your health" }, /* Con */

{ 0, 0 }, /* Cha */

};

exerchk(void)

{

int i, ax, mod_val, lolim, hilim;

/* Check out the periodic accumulations */

exerper();

if (svm.moves >= svc.context.next_attrib_check) {

debugpline1("exerchk: ready to test. multi = %ld.", gm.multi);

}

/* Are we ready for a test? */

if (svm.moves >= svc.context.next_attrib_check && !gm.multi) {

debugpline0("exerchk: testing.");

/*

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

ax = AEXE(i);

/* nothing to do here if no exercise or abuse has occurred

if (!ax)

continue; /* ok to skip nextattrib */

mod_val = sgn(ax); /* +1 or -1; used below */

/* no further effect for exercise if at max or abuse if at min;

lolim = ATTRMIN(i); /* usually 3; might be higher */

hilim = ATTRMAX(i); /* usually 18; maybe lower or higher */

if (hilim > 18)

hilim = 18;

if ((ax < 0) ? (ABASE(i) <= lolim) : (ABASE(i) >= hilim))

goto nextattrib;

/* can't exercise non-Wisdom while polymorphed; previous

if (Upolyd && i != A_WIS)

goto nextattrib;

debugpline2("exerchk: testing %s (%d).",

(i == A_STR) ? "Str"

: (i == A_INT) ? "Int?"

: (i == A_WIS) ? "Wis"

: (i == A_DEX) ? "Dex"

: (i == A_CON) ? "Con"

: (i == A_CHA) ? "Cha?"

: "???",

ax);

/*

if (rn2(AVAL) > ((i != A_WIS) ? (abs(ax) * 2 / 3) : abs(ax)))

goto nextattrib;

debugpline1("exerchk: changing %d.", i);

if (adjattrib(i, mod_val, -1)) {

debugpline1("exerchk: changed %d.", i);

/* if you actually changed an attrib - zero accumulation */

AEXE(i) = ax = 0;

/* then print an explanation */

You("%s %s.",

(mod_val > 0) ? "must have been" : "haven't been",

exertext[i][(mod_val > 0) ? 0 : 1]);

}

nextattrib:

/* this used to be ``AEXE(i) /= 2'' but that would produce

AEXE(i) = (abs(ax) / 2) * mod_val;

}

svc.context.next_attrib_check += rn1(200, 800);

debugpline1("exerchk: next check at %ld.",

svc.context.next_attrib_check);

}

}

staticfn int

rnd_attr(void)

{

int i, x = rn2(100);

/* 5.0: the x -= ... calculation used to have an off by 1 error that

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

if ((x -= gu.urole.attrdist[i]) < 0)

break;

return i;

}

staticfn int

init_attr_role_redist(int np, boolean addition)

{

int tryct = 0;

int adj = addition ? 1 : -1;

while ((addition ? (np > 0) : (np < 0)) && tryct < 100) {

int i = rnd_attr();

if (i >= A_MAX

|| (addition ? (ABASE(i) >= ATTRMAX(i))

: (ABASE(i) <= ATTRMIN(i)))) {

tryct++;

continue;

}

tryct = 0;

ABASE(i) += adj;

AMAX(i) += adj;

np -= adj;

}

return np;

}

init_attr(int np)

{

int i;

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

ABASE(i) = AMAX(i) = gu.urole.attrbase[i];

ATEMP(i) = ATIME(i) = 0;

np -= gu.urole.attrbase[i];

}

/* distribute leftover points */

np = init_attr_role_redist(np, TRUE);

/* if we went over, remove points */

np = init_attr_role_redist(np, FALSE);

}

redist_attr(void)

{

int i, tmp;

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

if (i == A_INT || i == A_WIS)

continue;

/* Polymorphing doesn't change your mind */

tmp = AMAX(i);

AMAX(i) += (rn2(5) - 2);

if (AMAX(i) > ATTRMAX(i))

AMAX(i) = ATTRMAX(i);

if (AMAX(i) < ATTRMIN(i))

AMAX(i) = ATTRMIN(i);

ABASE(i) = ABASE(i) * AMAX(i) / tmp;

/* ABASE(i) > ATTRMAX(i) is impossible */

if (ABASE(i) < ATTRMIN(i))

ABASE(i) = ATTRMIN(i);

}

/* encumber_msg(); -- caller needs to do this */

}

vary_init_attr(void)

{

int i;

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

if (!rn2(20)) {

int xd = rn2(7) - 2; /* biased variation */

(void) adjattrib(i, xd, TRUE);

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

AMAX(i) = ABASE(i);

}

}

postadjabil(long *ability)

{

if (!u.ulevel) /* initializing hero; don't attempt screen update yet */

return;

if (ability == &(HWarning) || ability == &(HSee_invisible))

see_monsters();

}

staticfn const struct innate *

role_abil(int r)

{

const struct {

short role;

const struct innate *abil;

} roleabils[] = {

{ PM_ARCHEOLOGIST, arc_abil },

{ PM_BARBARIAN, bar_abil },

{ PM_CAVE_DWELLER, cav_abil },

{ PM_HEALER, hea_abil },

{ PM_KNIGHT, kni_abil },

{ PM_MONK, mon_abil },

{ PM_CLERIC, pri_abil },

{ PM_RANGER, ran_abil },

{ PM_ROGUE, rog_abil },

{ PM_SAMURAI, sam_abil },

{ PM_TOURIST, tou_abil },

{ PM_VALKYRIE, val_abil },

{ PM_WIZARD, wiz_abil },

{ 0, 0 }

};

int i;

for (i = 0; roleabils[i].abil && roleabils[i].role != r; i++)

continue;

return roleabils[i].abil;

}

staticfn const struct innate *

check_innate_abil(long *ability, long frommask)

{

const struct innate *abil = 0;

if (frommask == FROMEXPER)

abil = role_abil(Role_switch);

else if (frommask == FROMRACE)

switch (Race_switch) {

case PM_DWARF:

abil = dwa_abil;

break;

case PM_ELF:

abil = elf_abil;

break;

case PM_GNOME:

abil = gno_abil;

break;

case PM_ORC:

abil = orc_abil;

break;

case PM_HUMAN:

abil = hum_abil;

break;

default:

break;

}

while (abil && abil->ability) {

if ((abil->ability == ability) && (u.ulevel >= abil->ulevel))

return abil;

abil++;

}

return (struct innate *) 0;

}

#define FROM_NONE 0

#define FROM_ROLE 1 /* from experience at level 1 */

#define FROM_RACE 2

#define FROM_INTR 3 /* intrinsically (eating some corpse or prayer reward) */

#define FROM_EXP 4 /* from experience for some level > 1 */

#define FROM_FORM 5

#define FROM_LYCN 6

staticfn int

innately(long *ability)

{

const struct innate *iptr;

if ((iptr = check_innate_abil(ability, FROMEXPER)) != 0)

return (iptr->ulevel == 1) ? FROM_ROLE : FROM_EXP;

if ((iptr = check_innate_abil(ability, FROMRACE)) != 0)

return FROM_RACE;

if ((*ability & FROMOUTSIDE) != 0L)

return FROM_INTR;

if ((*ability & FROMFORM) != 0L)

return FROM_FORM;

return FROM_NONE;

}

is_innate(int propidx)

{

int innateness;

/* innately() would report FROM_FORM for this; caller wants specificity */

if (propidx == DRAIN_RES && ismnum(u.ulycn))

return FROM_LYCN;

if (propidx == FAST && Very_fast)

return FROM_NONE; /* can't become very fast innately */

if ((innateness = innately(&u.uprops[propidx].intrinsic)) != FROM_NONE)

return innateness;

if (propidx == JUMPING && Role_if(PM_KNIGHT)

/* knight has intrinsic jumping, but extrinsic is more versatile so

&& !u.uprops[propidx].extrinsic)

return FROM_ROLE;

if ((propidx == BLINDED && !haseyes(gy.youmonst.data))

|| (propidx == BLND_RES && (HBlnd_resist & FROMFORM) != 0))

return FROM_FORM;

return FROM_NONE;

}

char *

from_what(

int propidx) /* special cases can have negative values */

{

static char buf[BUFSZ];

buf[0] = '\0';

/*

if (wizard) {

static NEARDATA const char because_of[] = " because of %s";

if (propidx >= 0) {

char *p;

struct obj *obj = (struct obj *) 0;

int innateness = is_innate(propidx);

/*

if ((propidx == BLINDED && u.uroleplay.blind)

|| (propidx == DEAF && u.uroleplay.deaf))

Sprintf(buf, " from birth");

else if (innateness == FROM_ROLE || innateness == FROM_RACE)

Strcpy(buf, " innately");

else if (innateness == FROM_INTR) /* [].intrinsic & FROMOUTSIDE */

Strcpy(buf, " intrinsically");

else if (innateness == FROM_EXP)

Strcpy(buf, " because of your experience");

else if (innateness == FROM_LYCN)

Strcpy(buf, " due to your lycanthropy");

else if (innateness == FROM_FORM)

Strcpy(buf, " from your creature form");

else if (propidx == FAST && Very_fast)

Sprintf(buf, because_of,

((HFast & TIMEOUT) != 0L) ? "a potion or spell"

: ((EFast & W_ARMF) != 0L && uarmf->dknown

&& objects[uarmf->otyp].oc_name_known)

? ysimple_name(uarmf) /* speed boots */

: EFast ? "worn equipment"

: something);

else if (wizard

&& (obj = what_gives(&u.uprops[propidx].extrinsic)) != 0)

Sprintf(buf, because_of, obj->oartifact

? bare_artifactname(obj)

: ysimple_name(obj));

else if (propidx == BLINDED && Blindfolded_only)

Sprintf(buf, because_of, ysimple_name(ublindf));

else if (propidx == BLINDED && u.ucreamed

&& BlindedTimeout == (long) u.ucreamed

&& !EBlinded && !(HBlinded & ~TIMEOUT))

Sprintf(buf, "due to goop covering your %s",

body_part(FACE));

/* remove some verbosity and/or redundancy */

if ((p = strstri(buf, " pair of ")) != 0)

copynchars(p + 1, p + 9, BUFSZ); /* overlapping buffers ok */

else if (propidx == STRANGLED

&& (p = strstri(buf, " of strangulation")) != 0)

*p = '\0';

} else { /* negative property index */

/* if more blocking capabilities get implemented we'll need to

switch (-propidx) {

case BLINDED:

/* wearing the Eyes of the Overworld overrides blindness */

if (BBlinded && is_art(ublindf, ART_EYES_OF_THE_OVERWORLD))

Sprintf(buf, because_of, bare_artifactname(ublindf));

break;

case INVIS:

if (u.uprops[INVIS].blocked & W_ARMC)

Sprintf(buf, because_of,

ysimple_name(uarmc)); /* mummy wrapping */

break;

case CLAIRVOYANT:

if (wizard && (u.uprops[CLAIRVOYANT].blocked & W_ARMH))

Sprintf(buf, because_of,

ysimple_name(uarmh)); /* cornuthaum */

break;

}

}

} /*wizard*/

return buf;