#include "hack.h"

staticfn long itimeout(long);

staticfn long itimeout_incr(long, int);

staticfn void ghost_from_bottle(void);

staticfn int drink_ok(struct obj *);

staticfn void peffect_restore_ability(struct obj *);

staticfn void peffect_hallucination(struct obj *);

staticfn void peffect_water(struct obj *);

staticfn void peffect_booze(struct obj *);

staticfn void peffect_enlightenment(struct obj *);

staticfn void peffect_invisibility(struct obj *);

staticfn void peffect_see_invisible(struct obj *);

staticfn void peffect_paralysis(struct obj *);

staticfn void peffect_sleeping(struct obj *);

staticfn int peffect_monster_detection(struct obj *);

staticfn int peffect_object_detection(struct obj *);

staticfn void peffect_sickness(struct obj *);

staticfn void peffect_confusion(struct obj *);

staticfn void peffect_gain_ability(struct obj *);

staticfn void peffect_speed(struct obj *);

staticfn void peffect_blindness(struct obj *);

staticfn void peffect_gain_level(struct obj *);

staticfn void peffect_healing(struct obj *);

staticfn void peffect_extra_healing(struct obj *);

staticfn void peffect_full_healing(struct obj *);

staticfn void peffect_levitation(struct obj *);

staticfn void peffect_gain_energy(struct obj *);

staticfn void peffect_oil(struct obj *);

staticfn void peffect_acid(struct obj *);

staticfn void peffect_polymorph(struct obj *);

staticfn boolean H2Opotion_dip(struct obj *, struct obj *, boolean,

const char *);

staticfn short mixtype(struct obj *, struct obj *);

staticfn int dip_ok(struct obj *);

staticfn int dip_hands_ok(struct obj *);

staticfn void hold_potion(struct obj *, const char *, const char *,

const char *);

staticfn void poof(struct obj *);

staticfn boolean dip_potion_explosion(struct obj *, int);

staticfn int potion_dip(struct obj *obj, struct obj *potion);

static int drink_ok_extra = 0;

itimeout(long val)

{

if (val >= TIMEOUT)

val = TIMEOUT;

else if (val < 1L)

val = 0L;

return val;

}

itimeout_incr(long old, int incr)

{

return itimeout((old & TIMEOUT) + (long) incr);

}

set_itimeout(long *which, long val)

{

*which &= ~TIMEOUT;

*which |= itimeout(val);

}

incr_itimeout(long *which, int incr)

{

set_itimeout(which, itimeout_incr(*which, incr));

}

make_confused(long xtime, boolean talk)

{

long old = HConfusion;

if (Unaware)

talk = FALSE;

if (!xtime && old) {

if (talk)

You_feel("less %s now.", Hallucination ? "trippy" : "confused");

}

if ((xtime && !old) || (!xtime && old))

disp.botl = TRUE;

set_itimeout(&HConfusion, xtime);

}

make_stunned(long xtime, boolean talk)

{

long old = HStun;

if (Unaware)

talk = FALSE;

if (!xtime && old) {

if (talk)

You_feel("%s now.",

Hallucination ? "less wobbly" : "a bit steadier");

}

if (xtime && !old) {

if (talk) {

if (u.usteed)

You("wobble in the saddle.");

else

You("%s...", stagger(gy.youmonst.data, "stagger"));

}

}

if ((!xtime && old) || (xtime && !old))

disp.botl = TRUE;

set_itimeout(&HStun, xtime);

}

make_sick(long xtime,

const char *cause, /* sickness cause */

boolean talk,

int type)

{

struct kinfo *kptr;

long old = Sick;

#if 0 /* tell player even if hero is unconscious */

if (Unaware)

talk = FALSE;

if (xtime > 0L) {

if (Sick_resistance)

return;

if (!old) {

/* newly sick */

You_feel("deathly sick.");

} else {

/* already sick */

if (talk)

You_feel("%s worse.", xtime <= Sick / 2L ? "much" : "even");

}

set_itimeout(&Sick, xtime);

u.usick_type |= type;

disp.botl = TRUE;

} else if (old && (type & u.usick_type)) {

/* was sick, now not */

u.usick_type &= ~type;

if (u.usick_type) { /* only partly cured */

if (talk)

You_feel("somewhat better.");

set_itimeout(&Sick, Sick * 2); /* approximation */

} else {

if (talk)

You_feel("cured. What a relief!");

Sick = 0L; /* set_itimeout(&Sick, 0L) */

}

disp.botl = TRUE;

}

kptr = find_delayed_killer(SICK);

if (Sick) {

exercise(A_CON, FALSE);

/* setting delayed_killer used to be unconditional, but that's

if (xtime || !old || !kptr) {

int kpfx = ((cause && !strcmp(cause, "#wizintrinsic"))

? KILLED_BY : KILLED_BY_AN);

delayed_killer(SICK, kpfx, cause);

}

} else

dealloc_killer(kptr);

}

make_slimed(long xtime, const char *msg)

{

long old = Slimed;

#if 0 /* tell player even if hero is unconscious */

if (Unaware)

msg = 0;

set_itimeout(&Slimed, xtime);

if ((xtime != 0L) ^ (old != 0L)) {

disp.botl = TRUE;

if (msg)

pline("%s", msg);

}

if (!Slimed) {

dealloc_killer(find_delayed_killer(SLIMED));

/* fake appearance is set late in turn-to-slime countdown */

if (U_AP_TYPE == M_AP_MONSTER

&& gy.youmonst.mappearance == PM_GREEN_SLIME) {

gy.youmonst.m_ap_type = M_AP_NOTHING;

gy.youmonst.mappearance = 0;

}

}

}

make_stoned(long xtime, const char *msg, int killedby, const char *killername)

{

long old = Stoned;

#if 0 /* tell player even if hero is unconscious */

if (Unaware)

msg = 0;

set_itimeout(&Stoned, xtime);

if ((xtime != 0L) ^ (old != 0L)) {

disp.botl = TRUE;

if (msg)

pline("%s", msg);

}

if (!Stoned)

dealloc_killer(find_delayed_killer(STONED));

else if (!old)

delayed_killer(STONED, killedby, killername);

}

make_vomiting(long xtime, boolean talk)

{

long old = Vomiting;

if (Unaware)

talk = FALSE;

set_itimeout(&Vomiting, xtime);

disp.botl = TRUE;

if (!xtime && old)

if (talk)

You_feel("much less nauseated now.");

}

static const char vismsg[] = "vision seems to %s for a moment but is %s now.";

static const char eyemsg[] = "%s momentarily %s.";

make_blinded(long xtime, boolean talk)

{

long old = BlindedTimeout;

boolean u_could_see, can_see_now;

const char *eyes;

/* we probe ahead in case the Eyes of the Overworld

u_could_see = !Blind;

set_itimeout(&HBlinded, xtime ? 1L : 0L);

can_see_now = !Blind;

set_itimeout(&HBlinded, old);

if (Unaware)

talk = FALSE;

if (can_see_now && !u_could_see) { /* regaining sight */

if (talk) {

if (Hallucination)

pline("Far out! Everything is all cosmic again!");

else

You("can see again.");

}

} else if (old && !xtime) {

/* clearing temporary blindness without toggling blindness */

if (talk) {

if (!haseyes(gy.youmonst.data) || PermaBlind) {

strange_feeling((struct obj *) 0, (char *) 0);

} else if (Blindfolded) {

eyes = body_part(EYE);

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

eyes = makeplural(eyes);

Your(eyemsg, eyes, vtense(eyes, "itch"));

} else { /* Eyes of the Overworld */

Your(vismsg, "brighten", Hallucination ? "sadder" : "normal");

}

}

}

if (u_could_see && !can_see_now) { /* losing sight */

if (talk) {

if (Hallucination)

pline("Oh, bummer! Everything is dark! Help!");

else

pline("A cloud of darkness falls upon you.");

}

/* Before the hero goes blind, set the ball&chain variables. */

if (Punished)

set_bc(0);

} else if (!old && xtime) {

/* setting temporary blindness without toggling blindness */

if (talk) {

if (!haseyes(gy.youmonst.data) || PermaBlind) {

strange_feeling((struct obj *) 0, (char *) 0);

} else if (Blindfolded) {

eyes = body_part(EYE);

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

eyes = makeplural(eyes);

Your(eyemsg, eyes, vtense(eyes, "twitch"));

} else { /* Eyes of the Overworld */

Your(vismsg, "dim", Hallucination ? "happier" : "normal");

}

}

}

set_itimeout(&HBlinded, xtime);

if (u_could_see ^ can_see_now) { /* one or the other but not both */

toggle_blindness();

}

}

toggle_blindness(void)

{

boolean Stinging = (uwep && (EWarn_of_mon & W_WEP) != 0L);

/* blindness has just been toggled */

disp.botl = TRUE; /* status conditions need update */

gv.vision_full_recalc = 1; /* vision has changed */

/* this vision recalculation used to be deferred until moveloop(),

vision_recalc(0);

if (Blind_telepat || Infravision || Stinging)

see_monsters(); /* also counts EWarn_of_mon monsters */

/*

if (Stinging)

Sting_effects(-1);

/* update dknown flag for inventory picked up while blind */

if (!Blind)

learn_unseen_invent();

}

make_hallucinated(

long xtime, /* nonzero if this is an attempt to turn on hallucination */

boolean talk,

long mask) /* nonzero if resistance status should change by mask */

{

long old = HHallucination;

boolean changed = 0;

const char *message, *verb;

if (Unaware)

talk = FALSE;

message = (!xtime) ? "Everything %s SO boring now."

: "Oh wow! Everything %s so cosmic!";

verb = (!Blind) ? "looks" : "feels";

if (mask) {

if (HHallucination)

changed = TRUE;

if (!xtime)

EHalluc_resistance |= mask;

else

EHalluc_resistance &= ~mask;

} else {

if (!EHalluc_resistance && (!!HHallucination != !!xtime))

changed = TRUE;

set_itimeout(&HHallucination, xtime);

/* clearing temporary hallucination without toggling vision */

if (!changed && !HHallucination && old && talk) {

if (!haseyes(gy.youmonst.data)) {

strange_feeling((struct obj *) 0, (char *) 0);

} else if (Blind) {

const char *eyes = body_part(EYE);

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

eyes = makeplural(eyes);

Your(eyemsg, eyes, vtense(eyes, "itch"));

} else { /* Grayswandir */

Your(vismsg, "flatten", "normal");

}

}

}

if (changed) {

/* in case we're mimicking an orange (hallucinatory form

if (!Hallucination)

eatmupdate();

if (u.uswallow) {

swallowed(0); /* redraw swallow display */

} else {

/* The see_* routines should be called *before* the pline. */

see_monsters();

see_objects();

see_traps();

}

/* for perm_inv and anything similar

update_inventory();

disp.botl = TRUE;

if (talk)

pline(message, verb);

}

return changed;

}

make_deaf(long xtime, boolean talk)

{

long old = HDeaf;

if (Unaware)

talk = FALSE;

set_itimeout(&HDeaf, xtime);

if ((xtime != 0L) ^ (old != 0L)) {

disp.botl = TRUE;

if (talk)

You(old && !Deaf ? "can hear again."

: "are unable to hear anything.");

}

}

make_glib(int xtime)

{

disp.botl |= (!Glib ^ !!xtime);

set_itimeout(&Glib, xtime);

/* may change "(being worn)" to "(being worn; slippery)" or vice versa */

if (uarmg)

update_inventory();

}

self_invis_message(void)

{

pline("%s %s.",

Hallucination ? "Far out, man! You"

: "Gee! All of a sudden, you",

See_invisible ? "can see right through yourself"

: "can't see yourself");

}

staticfn void

ghost_from_bottle(void)

{

struct monst *mtmp = makemon(&mons[PM_GHOST], u.ux, u.uy, MM_NOMSG);

if (!mtmp) {

pline("This bottle turns out to be empty.");

return;

}

if (Blind) {

pline("As you open the bottle, %s emerges.", something);

return;

}

pline("As you open the bottle, an enormous %s emerges!",

Hallucination ? rndmonnam(NULL) : (const char *) "ghost");

if (flags.verbose)

You("are frightened to death, and unable to move.");

nomul(-3);

gm.multi_reason = "being frightened to death";

gn.nomovemsg = "You regain your composure.";

}

staticfn int

drink_ok(struct obj *obj)

{

/* getobj()'s callback to test whether hands/self is a valid "item" to

if (!obj)

return drink_ok_extra ? GETOBJ_EXCLUDE_NONINVENT : GETOBJ_EXCLUDE;

if (obj->oclass == POTION_CLASS)

return GETOBJ_SUGGEST;

return GETOBJ_EXCLUDE;

}

dodrink(void)

{

struct obj *otmp;

if (Strangled) {

pline("If you can't breathe air, how can you drink liquid?");

return ECMD_OK;

}

drink_ok_extra = 0;

/* preceding 'q'/#quaff with 'm' skips the possibility of drinking

if (!iflags.menu_requested) {

/* Is there a fountain to drink from here? */

if (IS_FOUNTAIN(levl[u.ux][u.uy].typ)

/* not as low as floor level but similar restrictions apply */

&& can_reach_floor(FALSE)) {

if (y_n("Drink from the fountain?") == 'y') {

drinkfountain();

return ECMD_TIME;

}

++drink_ok_extra;

}

/* Or a kitchen sink? */

if (IS_SINK(levl[u.ux][u.uy].typ)

/* not as low as floor level but similar restrictions apply */

&& can_reach_floor(FALSE)) {

if (y_n("Drink from the sink?") == 'y') {

drinksink();

return ECMD_TIME;

}

++drink_ok_extra;

}

/* Or are you surrounded by water? */

if (Underwater && !u.uswallow) {

if (y_n("Drink the water around you?") == 'y') {

pline("Do you know what lives in this water?");

return ECMD_TIME;

}

++drink_ok_extra;

}

}

otmp = getobj("drink", drink_ok, GETOBJ_NOFLAGS);

if (!otmp)

return ECMD_CANCEL;

/*

if (otmp->owornmask) {

if (otmp->quan > 1L) {

otmp = splitobj(otmp, 1L);

otmp->owornmask = 0L; /* rest of original stack is unaffected */

} else {

remove_worn_item(otmp, FALSE);

}

}

otmp->in_use = TRUE; /* you've opened the stopper */

if (objdescr_is(otmp, "milky")

&& !(svm.mvitals[PM_GHOST].mvflags & G_GONE)

&& !rn2(POTION_OCCUPANT_CHANCE(svm.mvitals[PM_GHOST].born))) {

ghost_from_bottle();

useup(otmp);

return ECMD_TIME;

} else if (objdescr_is(otmp, "smoky")

&& !(svm.mvitals[PM_DJINNI].mvflags & G_GONE)

&& !rn2(POTION_OCCUPANT_CHANCE(svm.mvitals[PM_DJINNI].born))) {

djinni_from_bottle(otmp);

useup(otmp);

return ECMD_TIME;

}

return dopotion(otmp);

}

dopotion(struct obj *otmp)

{

int retval;

otmp->in_use = TRUE;

gp.potion_nothing = gp.potion_unkn = 0;

if ((retval = peffects(otmp)) >= 0)

return retval ? ECMD_TIME : ECMD_OK;

if (gp.potion_nothing) {

gp.potion_unkn++;

You("have a %s feeling for a moment, then it passes.",

Hallucination ? "normal" : "peculiar");

}

if (otmp->dknown && !objects[otmp->otyp].oc_name_known) {

if (!gp.potion_unkn) {

makeknown(otmp->otyp);

more_experienced(0, 10);

} else

trycall(otmp);

}

useup(otmp);

return ECMD_TIME;

}

staticfn void

peffect_restore_ability(struct obj *otmp)

{

gp.potion_unkn++;

if (otmp->cursed) {

pline("Ulch! This makes you feel mediocre!");

return;

} else {

int i, ii;

/* unlike unicorn horn, overrides Fixed_abil;

pline("Wow! This makes you feel %s!",

(!otmp->blessed) ? "good"

: unfixable_trouble_count(FALSE) ? "better"

: "great");

i = rn2(A_MAX); /* start at a random point */

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

int lim = AMAX(i);

/* this used to adjust 'lim' for A_STR when u.uhs was

if (ABASE(i) < lim) {

ABASE(i) = lim;

/* reset stat abuse (but not exercise) to 0 as well */

AEXE(i) = max(AEXE(i), 0);

disp.botl = TRUE;

/* only first found if not blessed */

if (!otmp->blessed)

break;

}

if (++i >= A_MAX)

i = 0;

}

/* when using the potion (not the spell) also restore lost levels,

if (otmp->otyp == POT_RESTORE_ABILITY && u.ulevel < u.ulevelmax) {

do {

pluslvl(FALSE);

} while (u.ulevel < u.ulevelmax && otmp->blessed);

}

}

}

staticfn void

peffect_hallucination(struct obj *otmp)

{

if (Halluc_resistance) {

gp.potion_nothing++;

return;

} else if (Hallucination) {

gp.potion_nothing++;

}

(void) make_hallucinated(itimeout_incr(HHallucination,

rn1(200, 600 - 300 * bcsign(otmp))),

TRUE, 0L);

if ((otmp->blessed && !rn2(3)) || (!otmp->cursed && !rn2(6))) {

You("perceive yourself...");

display_nhwindow(WIN_MESSAGE, FALSE);

enlightenment(MAGICENLIGHTENMENT, ENL_GAMEINPROGRESS);

Your("awareness re-normalizes.");

exercise(A_WIS, TRUE);

}

}

staticfn void

peffect_water(struct obj *otmp)

{

if (!otmp->blessed && !otmp->cursed) {

pline("This tastes like %s.", hliquid("water"));

u.uhunger += rnd(10);

newuhs(FALSE);

return;

}

gp.potion_unkn++;

if (mon_hates_blessings(&gy.youmonst) /* undead or demon */

|| u.ualign.type == A_CHAOTIC) {

if (otmp->blessed) {

pline("This burns like %s!", hliquid("acid"));

exercise(A_CON, FALSE);

if (ismnum(u.ulycn)) {

Your("affinity to %s disappears!",

makeplural(mons[u.ulycn].pmnames[NEUTRAL]));

if (gy.youmonst.data == &mons[u.ulycn])

you_unwere(FALSE);

set_ulycn(NON_PM); /* cure lycanthropy */

}

losehp(Maybe_Half_Phys(d(2, 6)), "potion of holy water",

KILLED_BY_AN);

} else if (otmp->cursed) {

You_feel("quite proud of yourself.");

healup(d(2, 6), 0, 0, 0);

if (ismnum(u.ulycn) && !Upolyd)

you_were();

exercise(A_CON, TRUE);

}

} else {

if (otmp->blessed) {

You_feel("full of awe.");

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

exercise(A_WIS, TRUE);

exercise(A_CON, TRUE);

if (ismnum(u.ulycn))

you_unwere(TRUE); /* "Purified" */

/* make_confused(0L, TRUE); */

} else {

if (u.ualign.type == A_LAWFUL) {

pline("This burns like %s!", hliquid("acid"));

losehp(Maybe_Half_Phys(d(2, 6)), "potion of unholy water",

KILLED_BY_AN);

} else

You_feel("full of dread.");

if (ismnum(u.ulycn) && !Upolyd)

you_were();

exercise(A_CON, FALSE);

}

}

}

staticfn void

peffect_booze(struct obj *otmp)

{

gp.potion_unkn++;

pline("Ooph! This tastes like %s%s!",

otmp->odiluted ? "watered down " : "",

Hallucination ? "dandelion wine" : "liquid fire");

if (!otmp->blessed) {

/* booze hits harder if drinking on an empty stomach */

make_confused(itimeout_incr(HConfusion, d(2 + u.uhs, 8)), FALSE);

}

/* the whiskey makes us feel better */

if (!otmp->odiluted)

healup(1, 0, FALSE, FALSE);

u.uhunger += 10 * (2 + bcsign(otmp));

newuhs(FALSE);

exercise(A_WIS, FALSE);

if (otmp->cursed) {

You("pass out.");

gm.multi = -rnd(15);

gn.nomovemsg = "You awake with a headache.";

}

}

staticfn void

peffect_enlightenment(struct obj *otmp)

{

if (otmp->cursed) {

gp.potion_unkn++;

You("have an uneasy feeling...");

exercise(A_WIS, FALSE);

} else {

if (otmp->blessed) {

(void) adjattrib(A_INT, 1, FALSE);

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

}

do_enlightenment_effect();

}

}

staticfn void

peffect_invisibility(struct obj *otmp)

{

boolean is_spell = (otmp->oclass == SPBOOK_CLASS);

/* spell cannot penetrate mummy wrapping */

if (is_spell && BInvis && uarmc->otyp == MUMMY_WRAPPING) {

You_feel("rather itchy under %s.", yname(uarmc));

return;

}

if (Invis || Blind || BInvis) {

gp.potion_nothing++;

} else {

self_invis_message();

}

if (otmp->blessed && !rn2(HInvis ? 15 : 30))

HInvis |= FROMOUTSIDE;

else

incr_itimeout(&HInvis, d(6 - 3 * bcsign(otmp), 100) + 100);

newsym(u.ux, u.uy); /* update position */

if (otmp->cursed) {

pline("For some reason, you feel your presence is known.");

aggravate();

/* doing this gives temporary invisibility, but removes permanent

HInvis &= ~FROMOUTSIDE;

}

}

staticfn void

peffect_see_invisible(struct obj *otmp)

{

int msg = Invisible && !Blind;

int permchance = 10 - (HInvis ? 3 : 0) - (HSee_invisible ? 6 : 0);

gp.potion_unkn++;

if (otmp->cursed)

pline("Yecch! This tastes %s.",

Hallucination ? "overripe" : "rotten");

else

pline(

Hallucination

? "This tastes like 10%% real %s%s all-natural beverage."

: "This tastes like %s%s.",

otmp->odiluted ? "reconstituted " : "", fruitname(TRUE));

if (otmp->otyp == POT_FRUIT_JUICE) {

u.uhunger += (otmp->odiluted ? 5 : 10) * (2 + bcsign(otmp));

newuhs(FALSE);

return;

}

if (!otmp->cursed) {

/* Tell them they can see again immediately, which

make_blinded(0L, TRUE);

}

if (otmp->blessed && !rn2(permchance))

HSee_invisible |= FROMOUTSIDE;

else

incr_itimeout(&HSee_invisible, rn1(100, 750));

set_mimic_blocking(); /* do special mimic handling */

see_monsters(); /* see invisible monsters */

newsym(u.ux, u.uy); /* see yourself! */

if (msg && !Blind) { /* Blind possible if polymorphed */

You("can see through yourself, but you are visible!");

gp.potion_unkn--;

}

}

staticfn void

peffect_paralysis(struct obj *otmp)

{

if (Free_action) {

You("stiffen momentarily.");

} else {

if (Levitation || Is_airlevel(&u.uz) || Is_waterlevel(&u.uz))

You("are motionlessly suspended.");

else if (u.usteed)

You("are frozen in place!");

else

Your("%s are frozen to the %s!", makeplural(body_part(FOOT)),

surface(u.ux, u.uy));

nomul(-(rn1(10, 25 - 12 * bcsign(otmp))));

gm.multi_reason = "frozen by a potion";

gn.nomovemsg = You_can_move_again;

exercise(A_DEX, FALSE);

}

}

staticfn void

peffect_sleeping(struct obj *otmp)

{

if (Sleep_resistance || Free_action) {

monstseesu(M_SEEN_SLEEP);

You("yawn.");

} else {

You("suddenly fall asleep!");

monstunseesu(M_SEEN_SLEEP);

fall_asleep(-rn1(10, 25 - 12 * bcsign(otmp)), TRUE);

}

}

staticfn int

peffect_monster_detection(struct obj *otmp)

{

if (otmp->blessed) {

int i, x, y;

if (Detect_monsters)

gp.potion_nothing++;

gp.potion_unkn++;

/* after a while, repeated uses become less effective */

if ((HDetect_monsters & TIMEOUT) >= 300L)

i = 1;

else if (otmp->oclass == SPBOOK_CLASS)

i = rn1(40, 21);

else /* potion */

i = rn2(100) + 100;

incr_itimeout(&HDetect_monsters, i);

for (x = 1; x < COLNO; x++) {

for (y = 0; y < ROWNO; y++) {

if (levl[x][y].glyph == GLYPH_INVISIBLE) {

unmap_object(x, y);

newsym(x, y);

}

if (MON_AT(x, y))

gp.potion_unkn = 0;

}

}

/* if swallowed or underwater, fall through to uncursed case */

if (!u.uswallow && !Underwater) {

see_monsters();

if (gp.potion_unkn)

You_feel("lonely.");

return 0;

}

}

if (monster_detect(otmp, 0))

return 1; /* nothing detected */

exercise(A_WIS, TRUE);

return 0;

}

staticfn int

peffect_object_detection(struct obj *otmp)

{

if (object_detect(otmp, 0))

return 1; /* nothing detected */

exercise(A_WIS, TRUE);

return 0;

}

staticfn void

peffect_sickness(struct obj *otmp)

{

pline("Yecch! This stuff tastes like poison.");

if (otmp->blessed) {

pline("(But in fact it was mildly stale %s.)", fruitname(TRUE));

if (!Role_if(PM_HEALER)) {

/* NB: blessed otmp->fromsink is not possible */

losehp(1, "mildly contaminated potion", KILLED_BY_AN);

}

} else {

if (Poison_resistance)

pline("(But in fact it was biologically contaminated %s.)",

fruitname(TRUE));

if (Role_if(PM_HEALER)) {

pline("Fortunately, you have been immunized.");

} else {

char contaminant[BUFSZ];

int typ = rn2(A_MAX);

Sprintf(contaminant, "%s%s",

(Poison_resistance) ? "mildly " : "",

(otmp->fromsink) ? "contaminated tap water"

: "contaminated potion");

if (!Fixed_abil) {

poisontell(typ, FALSE);

(void) adjattrib(typ, Poison_resistance ? -1 : -rn1(4, 3),

1);

}

if (!Poison_resistance) {

if (otmp->fromsink)

losehp(rnd(10) + 5 * !!(otmp->cursed), contaminant,

KILLED_BY);

else

losehp(rnd(10) + 5 * !!(otmp->cursed), contaminant,

KILLED_BY_AN);

} else {

/* rnd loss is so that unblessed poorer than blessed */