/* NetHack 3.5	eat.c	$NHDT-Date: 1426465435 2015/03/16 00:23:55 $  $NHDT-Branch: debug $:$NHDT-Revision: 1.123 $ */
/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
/* NetHack may be freely redistributed.  See license for details. */

#include "hack.h"

STATIC_PTR int NDECL(eatmdone);
STATIC_PTR int NDECL(eatfood);
STATIC_PTR void FDECL(costly_tin, (int));
STATIC_PTR int NDECL(opentin);
STATIC_PTR int NDECL(unfaint);

STATIC_DCL const char *FDECL(food_xname, (struct obj *,BOOLEAN_P));
STATIC_DCL void FDECL(choke, (struct obj *));
STATIC_DCL void NDECL(recalc_wt);
STATIC_DCL struct obj *FDECL(touchfood, (struct obj *));
STATIC_DCL void NDECL(do_reset_eat);
STATIC_DCL void FDECL(done_eating, (BOOLEAN_P));
STATIC_DCL void FDECL(cprefx, (int));
STATIC_DCL int FDECL(intrinsic_possible, (int,struct permonst *));
STATIC_DCL void FDECL(givit, (int,struct permonst *));
STATIC_DCL void FDECL(cpostfx, (int));
STATIC_DCL void FDECL(consume_tin, (const char *));
STATIC_DCL void FDECL(start_tin, (struct obj *));
STATIC_DCL int FDECL(eatcorpse, (struct obj *));
STATIC_DCL void FDECL(start_eating, (struct obj *));
STATIC_DCL void FDECL(fprefx, (struct obj *));
STATIC_DCL void FDECL(fpostfx, (struct obj *));
STATIC_DCL int NDECL(bite);
STATIC_DCL int FDECL(edibility_prompts, (struct obj *));
STATIC_DCL int FDECL(rottenfood, (struct obj *));
STATIC_DCL void NDECL(eatspecial);
STATIC_DCL int FDECL(bounded_increase, (int,int,int));
STATIC_DCL void FDECL(accessory_has_effect, (struct obj *));
STATIC_DCL void FDECL(eataccessory, (struct obj *));
STATIC_DCL const char *FDECL(foodword, (struct obj *));
STATIC_DCL int FDECL(tin_variety, (struct obj *,BOOLEAN_P));
STATIC_DCL boolean FDECL(maybe_cannibal, (int,BOOLEAN_P));

char msgbuf[BUFSZ];

/* also used to see if you're allowed to eat cats and dogs */
#define CANNIBAL_ALLOWED() (Role_if(PM_CAVEMAN) || Race_if(PM_ORC))

/* monster types that cause hero to be turned into stone if eaten */
#define flesh_petrifies(pm) (touch_petrifies(pm) || (pm) == &mons[PM_MEDUSA])

/* Rider corpses are treated as non-rotting so that attempting to eat one
   will be sure to reach the stage of eating where that meal is fatal */
#define nonrotting_corpse(mnum) ((mnum) == PM_LIZARD || \
				 (mnum) == PM_LICHEN || \
				 is_rider(&mons[mnum]))

/* non-rotting non-corpses; unlike lizard corpses, these items will behave
   as if rotten if they are cursed (fortune cookies handled elsewhere) */
#define nonrotting_food(otyp) ((otyp) == LEMBAS_WAFER || (otyp) == CRAM_RATION)

STATIC_OVL NEARDATA const char comestibles[] = { FOOD_CLASS, 0 };
STATIC_OVL NEARDATA const char offerfodder[] = { FOOD_CLASS, AMULET_CLASS, 0 };

/* Gold must come first for getobj(). */
STATIC_OVL NEARDATA const char allobj[] = {
	COIN_CLASS, WEAPON_CLASS, ARMOR_CLASS, POTION_CLASS, SCROLL_CLASS,
	WAND_CLASS, RING_CLASS, AMULET_CLASS, FOOD_CLASS, TOOL_CLASS,
	GEM_CLASS, ROCK_CLASS, BALL_CLASS, CHAIN_CLASS, SPBOOK_CLASS, 0 };

STATIC_OVL boolean force_save_hs = FALSE;

/* see hunger states in hack.h - texts used on bottom line */
const char *hu_stat[] = {
	"Satiated",
	"        ",
	"Hungry  ",
	"Weak    ",
	"Fainting",
	"Fainted ",
	"Starved "
};

/*
 * Decide whether a particular object can be eaten by the possibly
 * polymorphed character.  Not used for monster checks.
 */
boolean
is_edible(obj)
register struct obj *obj;
{
	/* protect invocation tools but not Rider corpses (handled elsewhere)*/
     /* if (obj->oclass != FOOD_CLASS && obj_resists(obj, 0, 0)) */
	if (objects[obj->otyp].oc_unique)
		return FALSE;
	/* above also prevents the Amulet from being eaten, so we must never
	   allow fake amulets to be eaten either [which is already the case] */

	if (metallivorous(youmonst.data) && is_metallic(obj) &&
	    (youmonst.data != &mons[PM_RUST_MONSTER] || is_rustprone(obj)))
		return TRUE;
	if (u.umonnum == PM_GELATINOUS_CUBE && is_organic(obj) &&
		/* [g.cubes can eat containers and retain all contents
		    as engulfed items, but poly'd player can't do that] */
	    !Has_contents(obj))
		return TRUE;

     /* return((boolean)(!!index(comestibles, obj->oclass))); */
	return (boolean)(obj->oclass == FOOD_CLASS);
}

void
init_uhunger()
{
	u.uhunger = 900;
	u.uhs = NOT_HUNGRY;
}

/* tin types [SPINACH_TIN = -1, overrides corpsenm, nut==600] */
static const struct {
    const char *txt;			/* description */
    int nut;				/* nutrition */
    Bitfield(fodder,1);			/* stocked by health food shops */
    Bitfield(greasy,1);			/* causes slippery fingers */
} tintxts[] = {
    {"rotten",	       -50, 0, 0},	/* ROTTEN_TIN = 0 */
    {"homemade",	50, 1, 0},	/* HOMEMADE_TIN = 1 */
    {"soup made from",	20, 1, 0},
    {"french fried",	40, 0, 1},
    {"pickled",		40, 1, 0},
    {"boiled",		50, 1, 0},
    {"smoked",		50, 1, 0},
    {"dried",		55, 1, 0},
    {"deep fried",	60, 0, 1},
    {"szechuan",	70, 1, 0},
    {"broiled",		80, 0, 0},
    {"stir fried",	80, 0, 1},
    {"sauteed",		95, 0, 0},
    {"candied",	       100, 1, 0},
    {"pureed",	       500, 1, 0},
    {"", 0, 0, 0}
};
#define TTSZ	SIZE(tintxts)

static char *eatmbuf = 0;	/* set by cpostfx() */

STATIC_PTR
int
eatmdone(VOID_ARGS)		/* called after mimicing is over */
{
	/* release `eatmbuf' */
	if (eatmbuf) {
	    if (nomovemsg == eatmbuf) nomovemsg = 0;
	    free((genericptr_t)eatmbuf),  eatmbuf = 0;
	}
	/* update display */
	if (youmonst.m_ap_type) {
	    youmonst.m_ap_type = M_AP_NOTHING;
	    newsym(u.ux,u.uy);
	}
	return 0;
}

/* called when hallucination is toggled */
void
eatmupdate()
{
	const char *altmsg = 0;
	int altapp = 0;	/* lint suppression */

	if (!eatmbuf || nomovemsg != eatmbuf) return;

	if (youmonst.m_ap_type == M_AP_OBJECT &&
		youmonst.mappearance == ORANGE &&
		!Hallucination) {
	    /* revert from hallucinatory to "normal" mimicking */
	    altmsg = "You now prefer mimicking yourself.";
	    altapp = GOLD_PIECE;
	} else if (youmonst.m_ap_type == M_AP_OBJECT &&
		youmonst.mappearance == GOLD_PIECE &&
		Hallucination) {
	    /* won't happen; anything which might make immobilized
	       hero begin hallucinating (black light attack, theft
	       of Grayswandir) will terminate the mimicry first */
	    altmsg = "Your rind escaped intact.";
	    altapp = ORANGE;
	}

	if (altmsg) {
	    /* replace end-of-mimicking message */
	    if (strlen(altmsg) > strlen(eatmbuf)) {
		free((genericptr_t) eatmbuf);
		eatmbuf = (char *) alloc(strlen(altmsg) + 1);
	    }
	    nomovemsg = strcpy(eatmbuf, altmsg);
	    /* update current image */
	    youmonst.mappearance = altapp;
	    newsym(u.ux, u.uy);
	}
}

/* ``[the(] singular(food, xname) [)]'' */
STATIC_OVL const char *
food_xname(food, the_pfx)
struct obj *food;
boolean the_pfx;
{
	const char *result;

	if (food->otyp == CORPSE) {
	    result = corpse_xname(food, (const char *)0,
				CXN_SINGULAR | (the_pfx ? CXN_PFX_THE : 0));
	    /* not strictly needed since pname values are capitalized
	       and the() is a no-op for them */
	    if (type_is_pname(&mons[food->corpsenm])) the_pfx = FALSE;
	} else {
	    /* the ordinary case */
	    result = singular(food, xname);
	}
	if (the_pfx) result = the(result);
	return result;
}

/* Created by GAN 01/28/87
 * Amended by AKP 09/22/87: if not hard, don't choke, just vomit.
 * Amended by 3.  06/12/89: if not hard, sometimes choke anyway, to keep risk.
 *		  11/10/89: if hard, rarely vomit anyway, for slim chance.
 */
STATIC_OVL void
choke(food)	/* To a full belly all food is bad. (It.) */
	register struct obj *food;
{
	/* only happens if you were satiated */
	if (u.uhs != SATIATED) {
		if (!food || food->otyp != AMULET_OF_STRANGULATION)
			return;
	} else if (Role_if(PM_KNIGHT) && u.ualign.type == A_LAWFUL) {
			adjalign(-1);		/* gluttony is unchivalrous */
			You_feel("like a glutton!");
	}

	exercise(A_CON, FALSE);

	if (Breathless || (!Strangled && !rn2(20))) {
	    /* choking by eating AoS doesn't involve stuffing yourself */
	    if (food && food->otyp == AMULET_OF_STRANGULATION) {
		You("choke, but recover your composure.");
		return;
	    }
	    You("stuff yourself and then vomit voluminously.");
	    morehungry(1000);	/* you just got *very* sick! */
	    vomit();
	} else {
	    killer.format = KILLED_BY_AN;
	    /*
	     * Note all "killer"s below read "Choked on %s" on the
	     * high score list & tombstone.  So plan accordingly.
	     */
	    if(food) {
		You("choke over your %s.", foodword(food));
		if (food->oclass == COIN_CLASS) {
		    Strcpy(killer.name, "very rich meal");
		} else {
		    killer.format = KILLED_BY;
		    Strcpy(killer.name, killer_xname(food));
		}
	    } else {
		You("choke over it.");
		Strcpy(killer.name, "quick snack");
	    }
	    You("die...");
	    done(CHOKING);
	}
}

/* modify object wt. depending on time spent consuming it */
STATIC_OVL void
recalc_wt()
{
	struct obj *piece = context.victual.piece;

	debugpline1("Old weight = %d", piece->owt);
	debugpline2("Used time = %d, Req'd time = %d",
		    context.victual.usedtime, context.victual.reqtime);
	piece->owt = weight(piece);
	debugpline1("New weight = %d", piece->owt);
}

void
reset_eat()		/* called when eating interrupted by an event */
{
    /* we only set a flag here - the actual reset process is done after
     * the round is spent eating.
     */
	if(context.victual.eating && !context.victual.doreset) {
	    debugpline0("reset_eat...");
	    context.victual.doreset = TRUE;
	}
	return;
}

STATIC_OVL struct obj *
touchfood(otmp)
register struct obj *otmp;
{
	if (otmp->quan > 1L) {
	    if(!carried(otmp))
		(void) splitobj(otmp, otmp->quan - 1L);
	    else
		otmp = splitobj(otmp, 1L);
	    debugpline0("split object,");
	}

	if (!otmp->oeaten) {
	    costly_alteration(otmp, COST_BITE);
	    otmp->oeaten = (otmp->otyp == CORPSE ?
				mons[otmp->corpsenm].cnutrit :
				objects[otmp->otyp].oc_nutrition);
	}

	if (carried(otmp)) {
	    freeinv(otmp);
	    if (inv_cnt(FALSE) >= 52) {
		sellobj_state(SELL_DONTSELL);
		dropy(otmp);
		sellobj_state(SELL_NORMAL);
	    } else {
		otmp->nomerge = 1;	/* used to prevent merge */
		otmp = addinv(otmp);
		otmp->nomerge = 0;
	    }
	}
	return(otmp);
}

/* When food decays, in the middle of your meal, we don't want to dereference
 * any dangling pointers, so set it to null (which should still trigger
 * do_reset_eat() at the beginning of eatfood()) and check for null pointers
 * in do_reset_eat().
 */
void
food_disappears(obj)
register struct obj *obj;
{
	if (obj == context.victual.piece) {
		context.victual.piece = (struct obj *)0;
		context.victual.o_id = 0;
	}
	if (obj->timed) obj_stop_timers(obj);
}

/* renaming an object usually results in it having a different address;
   so the sequence start eating/opening, get interrupted, name the food,
   resume eating/opening would restart from scratch */
void
food_substitution(old_obj, new_obj)
struct obj *old_obj, *new_obj;
{
	if (old_obj == context.victual.piece) {
		context.victual.piece = new_obj;
		context.victual.o_id = new_obj->o_id;
	}
	if (old_obj == context.tin.tin) {
		context.tin.tin = new_obj;
		context.tin.o_id =new_obj->o_id;
	}
}

STATIC_OVL void
do_reset_eat()
{
	debugpline0("do_reset_eat...");
	if (context.victual.piece) {
		context.victual.o_id = 0;
		context.victual.piece = touchfood(context.victual.piece);
		if (context.victual.piece)
			context.victual.o_id = context.victual.piece->o_id;
		recalc_wt();
	}
	context.victual.fullwarn = context.victual.eating = context.victual.doreset = FALSE;
	/* Do not set canchoke to FALSE; if we continue eating the same object
	 * we need to know if canchoke was set when they started eating it the
	 * previous time.  And if we don't continue eating the same object
	 * canchoke always gets recalculated anyway.
	 */
	stop_occupation();
	newuhs(FALSE);
}

STATIC_PTR
int
eatfood(VOID_ARGS)		/* called each move during eating process */
{
	if(!context.victual.piece ||
	   (!carried(context.victual.piece) &&
	    !obj_here(context.victual.piece, u.ux, u.uy))) {
		/* maybe it was stolen? */
		do_reset_eat();
		return(0);
	}
	if(!context.victual.eating) return(0);

	if(++context.victual.usedtime <= context.victual.reqtime) {
	    if(bite()) return(0);
	    return(1);	/* still busy */
	} else {	/* done */
	    done_eating(TRUE);
	    return(0);
	}
}

STATIC_OVL void
done_eating(message)
boolean message;
{
	context.victual.piece->in_use = TRUE;
	occupation = 0; /* do this early, so newuhs() knows we're done */
	newuhs(FALSE);
	if (nomovemsg) {
		if (message) pline1(nomovemsg);
		nomovemsg = 0;
	} else if (message)
		You("finish eating %s.", food_xname(context.victual.piece, TRUE));

	if(context.victual.piece->otyp == CORPSE)
		cpostfx(context.victual.piece->corpsenm);
	else
		fpostfx(context.victual.piece);

	if (carried(context.victual.piece)) useup(context.victual.piece);
	else useupf(context.victual.piece, 1L);
	context.victual.piece = (struct obj *) 0;
	context.victual.o_id = 0;
	context.victual.fullwarn = context.victual.eating = context.victual.doreset = FALSE;
}

void
eating_conducts(pd)
struct permonst *pd;
{
    u.uconduct.food++;
    if (!vegan(pd))
	u.uconduct.unvegan++;
    if (!vegetarian(pd))
	violated_vegetarian();
}

/* handle side-effects of mind flayer's tentacle attack */
int
eat_brains(magr, mdef, visflag, dmg_p)
struct monst *magr, *mdef;
boolean visflag;
int *dmg_p;	/* for dishing out extra damage in lieu of Int loss */
{
    struct permonst *pd = mdef->data;
    boolean give_nutrit = FALSE;
    int result = MM_HIT, xtra_dmg = rnd(10);

    if (noncorporeal(pd)) {
	if (visflag)
	    pline("%s brain is unharmed.",
		  (mdef == &youmonst) ? "Your" : s_suffix(Monnam(mdef)));
	return MM_MISS;	/* side-effects can't occur */
    } else if (magr == &youmonst) {
	You("eat %s brain!", s_suffix(mon_nam(mdef)));
    } else if (mdef == &youmonst) {
	Your("brain is eaten!");
    } else {		/* monster against monster */
	if (visflag) pline("%s brain is eaten!", s_suffix(Monnam(mdef)));
    }

    if (flesh_petrifies(pd)) {
	/* mind flayer has attempted to eat the brains of a petrification
	   inducing critter (most likely Medusa; attacking a cockatrice via
	   tentacle-touch should have been caught before reaching this far) */
	if (magr == &youmonst) {
	    if (!Stone_resistance && !Stoned)
		make_stoned(5L, (char *)0, KILLED_BY_AN, pd->mname);
	} else {
	    /* no need to check for poly_when_stoned or Stone_resistance;
	       mind flayers don't have those capabilities */
	    if (visflag) pline("%s turns to stone!", Monnam(magr));
	    monstone(magr);
	    if (magr->mhp > 0) {
		/* life-saved; don't continue eating the brains */
		return MM_MISS;
	    } else {
		if (magr->mtame && !visflag)
		    /* parallels mhitm.c's brief_feeling */
		    You("have a sad thought for a moment, then is passes.");
		return MM_AGR_DIED;
	    }
	}
    }

    if (magr == &youmonst) {
	/*
	 * player mind flayer is eating something's brain
	 */
	eating_conducts(pd);
	if (mindless(pd)) {		/* (cannibalism not possible here) */
	    pline("%s doesn't notice.", Monnam(mdef));
	    /* all done; no extra harm inflicted upon target */
	    return MM_MISS;
	} else if (is_rider(pd)) {
	    pline("Ingesting that is fatal.");
	    Sprintf(killer.name, "unwisely ate the brain of %s", pd->mname);
	    killer.format = NO_KILLER_PREFIX;
	    done(DIED);
	    /* life-saving needed to reach here */
	    exercise(A_WIS, FALSE);
	    *dmg_p += xtra_dmg;		/* Rider takes extra damage */
	} else {
	    morehungry(-rnd(30));	/* cannot choke */
	    if (ABASE(A_INT) < AMAX(A_INT)) {
		/* recover lost Int; won't increase current max */
		ABASE(A_INT) += rnd(4);
		if (ABASE(A_INT) > AMAX(A_INT)) ABASE(A_INT) = AMAX(A_INT);
		context.botl = 1;
	    }
	    exercise(A_WIS, TRUE);
	    *dmg_p += xtra_dmg;
	}
	/* targetting another mind flayer or your own underlying species
	   is cannibalism */
	(void) maybe_cannibal(monsndx(pd), TRUE);

    } else if (mdef == &youmonst) {
	/*
	 * monster mind flayer is eating hero's brain
	 */
	/* no such thing as mindless players */
	if (ABASE(A_INT) <= ATTRMIN(A_INT)) {
	    static NEARDATA const char brainlessness[] = "brainlessness";

	    if (Lifesaved) {
		Strcpy(killer.name, brainlessness);
		killer.format = KILLED_BY;
		done(DIED);
		/* amulet of life saving has now been used up */
		pline("Unfortunately your brain is still gone.");
		/* sanity check against adding other forms of life-saving */
		u.uprops[LIFESAVED].extrinsic =
			u.uprops[LIFESAVED].intrinsic = 0L;
	    } else {
		Your("last thought fades away.");
	    }
	    Strcpy(killer.name, brainlessness);
	    killer.format = KILLED_BY;
	    done(DIED);
	    /* can only get here when in wizard or explore mode and user has
	       explicitly chosen not to die; arbitrarily boost intelligence */
	    ABASE(A_INT) = ATTRMIN(A_INT) + 2;
	    You_feel("like a scarecrow.");
	}
	give_nutrit = TRUE;	/* in case a conflicted pet is doing this */
	exercise(A_WIS, FALSE);
	/* caller handles Int and memory loss */

    } else {		/* mhitm */
	/*
	 * monster mind flayer is eating another monster's brain
	 */
	if (mindless(pd)) {
	    if (visflag) pline("%s doesn't notice.", Monnam(mdef));
	    return MM_MISS;
	} else if (is_rider(pd)) {
	    mondied(magr);
	    if (magr->mhp <= 0) result = MM_AGR_DIED;
	    /* Rider takes extra damage regardless of whether attacker dies */
	    *dmg_p += xtra_dmg;
	} else {
	    *dmg_p += xtra_dmg;
	    give_nutrit = TRUE;
	    if (*dmg_p >= mdef->mhp && visflag)
		pline("%s last thought fades away...", s_suffix(Monnam(mdef)));
	}
    }

    if (give_nutrit && magr->mtame && !magr->isminion) {
	EDOG(magr)->hungrytime += rnd(60);
	magr->mconf = 0;
    }

    return result;
}

/* eating a corpse or egg of one's own species is usually naughty */
STATIC_OVL boolean
maybe_cannibal(pm, allowmsg)
int pm;
boolean allowmsg;
{
	static NEARDATA long ate_brains = 0L;
	struct permonst *fptr = &mons[pm];	/* food type */

	/* when poly'd into a mind flayer, multiple tentacle hits in one
	   turn cause multiple digestion checks to occur; avoid giving
	   multiple luck penalties for the same attack */
	if (moves == ate_brains) return FALSE;
	ate_brains = moves;	/* ate_anything, not just brains... */

	if (!CANNIBAL_ALLOWED() &&
		/* non-cannibalistic heroes shouldn't eat own species ever
		   and also shouldn't eat current species when polymorphed
		   (even if having the form of something which doesn't care
		   about cannibalism--hero's innate traits aren't altered) */
		(your_race(fptr) ||
		    (Upolyd && same_race(youmonst.data, fptr)))) {
		if (allowmsg) {
			if (Upolyd && your_race(fptr))
				You("have a bad feeling deep inside.");
			You("cannibal!  You will regret this!");
		}
		HAggravate_monster |= FROMOUTSIDE;
		change_luck(-rn1(4,2));		/* -5..-2 */
		return TRUE;
	}
	return FALSE;
}

STATIC_OVL void
cprefx(pm)
register int pm;
{
	(void) maybe_cannibal(pm,TRUE);
	if (flesh_petrifies(&mons[pm])) {
	    if (!Stone_resistance &&
		!(poly_when_stoned(youmonst.data) && polymon(PM_STONE_GOLEM))) {
		Sprintf(killer.name, "tasting %s meat", mons[pm].mname);
		killer.format = KILLED_BY;
		You("turn to stone.");
		done(STONING);
		if (context.victual.piece)
		    context.victual.eating = FALSE;
		return; /* lifesaved */
	    }
	}

	switch(pm) {
	    case PM_LITTLE_DOG:
	    case PM_DOG:
	    case PM_LARGE_DOG:
	    case PM_KITTEN:
	    case PM_HOUSECAT:
	    case PM_LARGE_CAT:
		if (!CANNIBAL_ALLOWED()) {
		    You_feel("that eating the %s was a bad idea.", mons[pm].mname);
		    HAggravate_monster |= FROMOUTSIDE;
		}
		break;
	    case PM_LIZARD:
		if (Stoned) fix_petrification();
		break;
	    case PM_DEATH:
	    case PM_PESTILENCE:
	    case PM_FAMINE:
		{
		    pline("Eating that is instantly fatal.");
		    Sprintf(killer.name, "unwisely ate the body of %s",
			    mons[pm].mname);
		    killer.format = NO_KILLER_PREFIX;
		    done(DIED);
		    /* life-saving needed to reach here */
		    exercise(A_WIS, FALSE);
		    /* It so happens that since we know these monsters */
		    /* cannot appear in tins, context.victual.piece will always */
		    /* be what we want, which is not generally true. */
		    if (revive_corpse(context.victual.piece)) {
			context.victual.piece = (struct obj *)0;
			context.victual.o_id = 0;
		    }
		    return;
		}
	    case PM_GREEN_SLIME:
		if (!Slimed && !Unchanging && !slimeproof(youmonst.data)) {
		    You("don't feel very well.");
		    make_slimed(10L, (char*) 0);
		    delayed_killer(SLIMED, KILLED_BY_AN, "");
		}
		/* Fall through */
	    default:
		if (acidic(&mons[pm]) && Stoned)
		    fix_petrification();
		break;
	}
}

void
fix_petrification()
{
    char buf[BUFSZ];

    if (Hallucination)
	Sprintf(buf, "What a pity--you just ruined a future piece of %sart!",
		ACURR(A_CHA) > 15 ? "fine " : "");
    else
	Strcpy(buf, "You feel limber!");
    make_stoned(0L, buf, 0, (char *)0);
}

/*
 * If you add an intrinsic that can be gotten by eating a monster, add it
 * to intrinsic_possible() and givit().  (It must already be in prop.h to
 * be an intrinsic property.)
 * It would be very easy to make the intrinsics not try to give you one
 * that you already had by checking to see if you have it in
 * intrinsic_possible() instead of givit(), but we're not that nice.
 */

/* intrinsic_possible() returns TRUE iff a monster can give an intrinsic. */
STATIC_OVL int
intrinsic_possible(type, ptr)
int type;
register struct permonst *ptr;
{
	int res = 0;

	switch (type) {
	case FIRE_RES:
		res = (ptr->mconveys & MR_FIRE) != 0;
		if (res) debugpline0("can get fire resistance");
		break;
	case SLEEP_RES:
		res = (ptr->mconveys & MR_SLEEP) != 0;
		if (res) debugpline0("can get sleep resistance");
		break;
	case COLD_RES:
		res = (ptr->mconveys & MR_COLD) != 0;
		if (res) debugpline0("can get cold resistance");
		break;
	case DISINT_RES:
		res = (ptr->mconveys & MR_DISINT) != 0;
		if (res) debugpline0("can get disintegration resistance");
		break;
	case SHOCK_RES:	/* shock (electricity) resistance */
		res = (ptr->mconveys & MR_ELEC) != 0;
		if (res) debugpline0("can get shock resistance");
		break;
	case POISON_RES:
		res = (ptr->mconveys & MR_POISON) != 0;
		if (res) debugpline0("can get poison resistance");
		break;
	case TELEPORT:
		res = can_teleport(ptr);
		if (res) debugpline0("can get teleport");
		break;
	case TELEPORT_CONTROL:
		res = control_teleport(ptr); 
		if (res) debugpline0("can get teleport control");
		break;
	case TELEPAT:
		res = telepathic(ptr);
		if (res) debugpline0("can get telepathy");
		break;
	default:
		/* res stays 0 */
		break;
	}
	return res;
}

/* givit() tries to give you an intrinsic based on the monster's level
 * and what type of intrinsic it is trying to give you.
 */
STATIC_OVL void
givit(type, ptr)
int type;
register struct permonst *ptr;
{
	register int chance;

	debugpline1("Attempting to give intrinsic %d", type);
	/* some intrinsics are easier to get than others */
	switch (type) {
		case POISON_RES:
			if ((ptr == &mons[PM_KILLER_BEE] ||
					ptr == &mons[PM_SCORPION]) && !rn2(4))
				chance = 1;
			else
				chance = 15;
			break;
		case TELEPORT:
			chance = 10;
			break;
		case TELEPORT_CONTROL:
			chance = 12;
			break;
		case TELEPAT:
			chance = 1;
			break;
		default:
			chance = 15;
			break;
	}

	if (ptr->mlevel <= rn2(chance))
		return;		/* failed die roll */

	switch (type) {
	    case FIRE_RES:
		debugpline0("Trying to give fire resistance");
		if(!(HFire_resistance & FROMOUTSIDE)) {
			You(Hallucination ? "be chillin'." :
			    "feel a momentary chill.");
			HFire_resistance |= FROMOUTSIDE;
		}
		break;
	    case SLEEP_RES:
		debugpline0("Trying to give sleep resistance");
		if(!(HSleep_resistance & FROMOUTSIDE)) {
			You_feel("wide awake.");
			HSleep_resistance |= FROMOUTSIDE;
		}
		break;
	    case COLD_RES:
		debugpline0("Trying to give cold resistance");
		if(!(HCold_resistance & FROMOUTSIDE)) {
			You_feel("full of hot air.");
			HCold_resistance |= FROMOUTSIDE;
		}
		break;
	    case DISINT_RES:
		debugpline0("Trying to give disintegration resistance");
		if(!(HDisint_resistance & FROMOUTSIDE)) {
			You_feel(Hallucination ?
			    "totally together, man." :
			    "very firm.");
			HDisint_resistance |= FROMOUTSIDE;
		}
		break;
	    case SHOCK_RES:	/* shock (electricity) resistance */
		debugpline0("Trying to give shock resistance");
		if(!(HShock_resistance & FROMOUTSIDE)) {
			if (Hallucination)
				You_feel("grounded in reality.");
			else
				Your("health currently feels amplified!");
			HShock_resistance |= FROMOUTSIDE;
		}
		break;
	    case POISON_RES:
		debugpline0("Trying to give poison resistance");
		if(!(HPoison_resistance & FROMOUTSIDE)) {
			You_feel(Poison_resistance ?
				 "especially healthy." : "healthy.");
			HPoison_resistance |= FROMOUTSIDE;
		}
		break;
	    case TELEPORT:
		debugpline0("Trying to give teleport");
		if(!(HTeleportation & FROMOUTSIDE)) {
			You_feel(Hallucination ? "diffuse." :
			    "very jumpy.");
			HTeleportation |= FROMOUTSIDE;
		}
		break;
	    case TELEPORT_CONTROL:
		debugpline0("Trying to give teleport control");
		if(!(HTeleport_control & FROMOUTSIDE)) {
			You_feel(Hallucination ?
			    "centered in your personal space." :
			    "in control of yourself.");
			HTeleport_control |= FROMOUTSIDE;
		}
		break;
	    case TELEPAT:
		debugpline0("Trying to give telepathy");
		if(!(HTelepat & FROMOUTSIDE)) {
			You_feel(Hallucination ?
			    "in touch with the cosmos." :
			    "a strange mental acuity.");
			HTelepat |= FROMOUTSIDE;
			/* If blind, make sure monsters show up. */
			if (Blind) see_monsters();
		}
		break;
	    default:
		debugpline0("Tried to give an impossible intrinsic");
		break;
	}
}

STATIC_OVL void
cpostfx(pm)		/* called after completely consuming a corpse */
register int pm;
{
	register int tmp = 0;
	boolean catch_lycanthropy = FALSE;

	/* in case `afternmv' didn't get called for previously mimicking
	   gold, clean up now to avoid `eatmbuf' memory leak */
	if (eatmbuf) (void)eatmdone();

	switch(pm) {
	    case PM_NEWT:
		/* MRKR: "eye of newt" may give small magical energy boost */
		if (rn2(3) || 3 * u.uen <= 2 * u.uenmax) {
		    int old_uen = u.uen;
		    u.uen += rnd(3);
		    if (u.uen > u.uenmax) {
			if (!rn2(3)) u.uenmax++;
			u.uen = u.uenmax;
		    }
		    if (old_uen != u.uen) {
			    You_feel("a mild buzz.");
			    context.botl = 1;
		    }
		}
		break;
	    case PM_WRAITH:
		pluslvl(FALSE);
		break;
	    case PM_HUMAN_WERERAT:
		catch_lycanthropy = TRUE;
		u.ulycn = PM_WERERAT;
		break;
	    case PM_HUMAN_WEREJACKAL:
		catch_lycanthropy = TRUE;
		u.ulycn = PM_WEREJACKAL;
		break;
	    case PM_HUMAN_WEREWOLF:
		catch_lycanthropy = TRUE;
		u.ulycn = PM_WEREWOLF;
		break;
	    case PM_NURSE:
		if (Upolyd) u.mh = u.mhmax;
		else u.uhp = u.uhpmax;
		context.botl = 1;
		break;
	    case PM_STALKER:
		if(!Invis) {
			set_itimeout(&HInvis, (long)rn1(100, 50));
			if (!Blind && !BInvis) self_invis_message();
		} else {
			if (!(HInvis & INTRINSIC)) You_feel("hidden!");
			HInvis |= FROMOUTSIDE;
			HSee_invisible |= FROMOUTSIDE;
		}
		newsym(u.ux, u.uy);
		/* fall into next case */
	    case PM_YELLOW_LIGHT:
		/* fall into next case */
	    case PM_GIANT_BAT:
		make_stunned((HStun & TIMEOUT) + 30L, FALSE);
		/* fall into next case */
	    case PM_BAT:
		make_stunned((HStun & TIMEOUT) + 30L, FALSE);
		break;
	    case PM_GIANT_MIMIC:
		tmp += 10;
		/* fall into next case */
	    case PM_LARGE_MIMIC:
		tmp += 20;
		/* fall into next case */
	    case PM_SMALL_MIMIC:
		tmp += 20;
		if (youmonst.data->mlet != S_MIMIC && !Unchanging) {
		    char buf[BUFSZ];

		    u.uconduct.polyselfs++;	/* you're changing form */
		    You_cant("resist the temptation to mimic %s.",
			Hallucination ? "an orange" : "a pile of gold");
		    /* A pile of gold can't ride. */
		    if (u.usteed) dismount_steed(DISMOUNT_FELL);
		    nomul(-tmp);
		    multi_reason = "pretending to be a pile of gold";
		    Sprintf(buf, Hallucination ?
			"You suddenly dread being peeled and mimic %s again!" :
			"You now prefer mimicking %s again.",
			an(Upolyd ? youmonst.data->mname : urace.noun));
		    eatmbuf = dupstr(buf);
		    nomovemsg = eatmbuf;
		    afternmv = eatmdone;
		    /* ??? what if this was set before? */
		    youmonst.m_ap_type = M_AP_OBJECT;
		    youmonst.mappearance = Hallucination ? ORANGE : GOLD_PIECE;
		    newsym(u.ux,u.uy);
		    curs_on_u();
		    /* make gold symbol show up now */
		    display_nhwindow(WIN_MAP, TRUE);
		}
		break;
	    case PM_QUANTUM_MECHANIC:
		Your("velocity suddenly seems very uncertain!");
		if (HFast & INTRINSIC) {
			HFast &= ~INTRINSIC;
			You("seem slower.");
		} else {
			HFast |= FROMOUTSIDE;
			You("seem faster.");
		}
		break;
	    case PM_LIZARD:
		if ((HStun & TIMEOUT) > 2)  make_stunned(2L, FALSE);
		if ((HConfusion & TIMEOUT) > 2)  make_confused(2L, FALSE);
		break;
	    case PM_CHAMELEON:
	    case PM_DOPPELGANGER:
	    case PM_SANDESTIN:	/* moot--they don't leave corpses */
		if (Unchanging) {
		    You_feel("momentarily different."); /* same as poly trap */
		} else {
		    You_feel("a change coming over you.");
		    polyself(0);
		}
		break;
	    case PM_DISENCHANTER:
		/* picks an intrinsic at random and removes it; there's
		   no feedback if hero already lacks the chosen ability */
		debugpline0("using attrcurse to strip an intrinsic");
		attrcurse();
		break;
	    case PM_MIND_FLAYER:
	    case PM_MASTER_MIND_FLAYER:
		if (ABASE(A_INT) < ATTRMAX(A_INT)) {
			if (!rn2(2)) {
				pline("Yum! That was real brain food!");
				(void) adjattrib(A_INT, 1, FALSE);
				break;	/* don't give them telepathy, too */
			}
		} else {
			pline("For some reason, that tasted bland.");
		}
		/*FALLTHRU*/
	    default:
	    {
		struct permonst *ptr = &mons[pm];
		boolean conveys_STR = is_giant(ptr);
		int i, count;

		if (dmgtype(ptr, AD_STUN) || dmgtype(ptr, AD_HALU) ||
			pm == PM_VIOLET_FUNGUS) {
		    pline("Oh wow!  Great stuff!");
		    (void)make_hallucinated((HHallucination & TIMEOUT) + 200L,
					    FALSE, 0L);
		}

		/* Check the monster for all of the intrinsics.  If this
		 * monster can give more than one, pick one to try to give
		 * from among all it can give.
		 *
		 * Strength from giants is now treated like an intrinsic
		 * rather than being given unconditionally.
		 */
		count = 0;	/* number of possible intrinsics */
		tmp = 0;	/* which one we will try to give */
		if (conveys_STR) {
		    count = 1;
		    tmp = -1;	/* use -1 as fake prop index for STR */
		    debugpline1("\"Intrinsic\" strength, %d", tmp);
		}
		for (i = 1; i <= LAST_PROP; i++) {
		    if (!intrinsic_possible(i, ptr)) continue;
		    ++count;
		    /* a 1 in count chance of replacing the old choice
		       with this one, and a count-1 in count chance
		       of keeping the old choice (note that 1 in 1 and
		       0 in 1 are what we want for the first candidate) */
		    if (!rn2(count)) {
			debugpline2("Intrinsic %d replacing %d", i, tmp);
			tmp = i;
		    }
		}
		/* if strength is the only candidate, give it 50% chance */
		if (conveys_STR && count == 1 && !rn2(2)) tmp = 0;
		/* if something was chosen, give it now (givit() might fail) */
		if (tmp == -1)
		    gainstr((struct obj *)0, 0, TRUE);
		else if (tmp > 0)
		    givit(tmp, ptr);
	    }
	    break;
	}

	if (catch_lycanthropy) retouch_equipment(2);

	return;
}

void
violated_vegetarian()
{
    u.uconduct.unvegetarian++;
    if (Role_if(PM_MONK)) {
	You_feel("guilty.");
	adjalign(-1);
    }
    return;
}

/* common code to check and possibly charge for 1 context.tin.tin,
 * will split() context.tin.tin if necessary */
STATIC_PTR
void
costly_tin(alter_type)
int alter_type;	/* COST_xxx */
{
    struct obj *tin = context.tin.tin;

    if (carried(tin) ? tin->unpaid :
	    (costly_spot(tin->ox, tin->oy) && !tin->no_charge)) {
	if (tin->quan > 1L) {
	    tin = context.tin.tin = splitobj(tin, 1L);
	    context.tin.o_id = tin->o_id;
	}
	costly_alteration(tin, alter_type);
    }
}

int
tin_variety_txt(s,tinvariety)
char *s;
int *tinvariety;
{
	int k, l;

	if (s && tinvariety) {
	    *tinvariety = -1;
	    for (k = 0; k < TTSZ-1; ++k) {
		l = (int)strlen(tintxts[k].txt);
		if (!strncmpi(s, tintxts[k].txt, l) &&
			((int)strlen(s) > l) && s[l] == ' ') {
			*tinvariety = k;
			return (l + 1);
		}
	    }
	}
	return 0;
}

/*
 * This assumes that buf already contains the word "tin",
 * as is the case with caller xname().
 */
void
tin_details(obj, mnum, buf)
struct obj *obj;
int mnum;
char *buf;
{
	char buf2[BUFSZ];
	int r = tin_variety(obj, TRUE);

	if (obj && buf) {
	    if (r == SPINACH_TIN)
		Strcat(buf, " of spinach");
	    else if (mnum == NON_PM)
		Strcpy(buf, "empty tin");
	    else {
		if ((obj->cknown || iflags.override_ID) && obj->spe < 0) {
		    if (r == ROTTEN_TIN || r == HOMEMADE_TIN) {
			/* put these before the word tin */
			Sprintf(buf2,"%s %s of ", tintxts[r].txt, buf);
			Strcpy(buf, buf2);
		    } else {
		    	Sprintf(eos(buf), " of %s ", tintxts[r].txt);
		    }
		} else {
		    Strcpy(eos(buf), " of ");
		}
	        if (vegetarian(&mons[mnum]))
		    Sprintf(eos(buf), "%s", mons[mnum].mname);
	        else
		    Sprintf(eos(buf), "%s meat", mons[mnum].mname);
	    }
	}
}

void
set_tin_variety(obj, forcetype)
struct obj *obj;
int forcetype;
{
	register int r;

	if (forcetype == SPINACH_TIN ||
		(forcetype == HEALTHY_TIN &&
		    (obj->corpsenm == NON_PM || /* empty or already spinach */
		     !vegetarian(&mons[obj->corpsenm])))) { /* replace meat */
		obj->corpsenm = NON_PM;	/* not based on any monster */
		obj->spe = 1;		/* spinach */
		return;
	} else if (forcetype == HEALTHY_TIN) {
		r = tin_variety(obj, FALSE);
		if (r < 0 || r >= TTSZ) r = ROTTEN_TIN;	/* shouldn't happen */
		while ((r == ROTTEN_TIN && !obj->cursed) || !tintxts[r].fodder)
		    r = rn2(TTSZ-1);
	} else if (forcetype >= 0 && forcetype < TTSZ-1) {
		r = forcetype;
	} else {	/* RANDOM_TIN */
		r = rn2(TTSZ-1);		/* take your pick */
		if (r == ROTTEN_TIN && nonrotting_corpse(obj->corpsenm))
			r = HOMEMADE_TIN;	/* lizards don't rot */
	}
	obj->spe = -(r+1);	/* offset by 1 to allow index 0 */
}

STATIC_OVL int
tin_variety(obj, disp)
struct obj *obj;
boolean disp;		/* we're just displaying so leave things alone */
{
	register int r;

	if (obj->spe == 1) {
		r = SPINACH_TIN;
	} else if (obj->cursed) {
		r = ROTTEN_TIN;			/* always rotten if cursed */
	} else if (obj->spe < 0) {
		r = -(obj->spe);
		--r;		/* get rid of the offset */
	} else 
		r = rn2(TTSZ-1);

	if (!disp && r == HOMEMADE_TIN &&
		 !obj->blessed && !rn2(7))
		r = ROTTEN_TIN;			/* some homemade tins go bad */	

	if (r == ROTTEN_TIN && nonrotting_corpse(obj->corpsenm))
		r = HOMEMADE_TIN;		/* lizards don't rot */
	return r;
}

STATIC_OVL
void
consume_tin(mesg)
const char *mesg;
{
    const char *what;
    int which, mnum, r;
    struct obj *tin = context.tin.tin;

    r = tin_variety(tin, FALSE);
    if (tin->otrapped || (tin->cursed && r != HOMEMADE_TIN && !rn2(8))) {
	b_trapped("tin", 0);
	costly_tin(COST_DSTROY);
	goto use_up_tin;
    }

    pline1(mesg);	/* "You succeed in opening the tin." */

    if (r != SPINACH_TIN) {
	mnum = tin->corpsenm;
	if (mnum == NON_PM) {
	    pline("It turns out to be empty.");
	    tin->dknown = tin->known = 1;
	    costly_tin(COST_OPEN);
	    goto use_up_tin;
	}

	which = 0;	/* 0=>plural, 1=>as-is, 2=>"the" prefix */
	if ((mnum == PM_COCKATRICE || mnum == PM_CHICKATRICE) &&
		(Stone_resistance || Hallucination)) {
	    what = "chicken";
	    which = 1;	/* suppress pluralization */
	} else if (Hallucination) {
	    what = rndmonnam(NULL);
	} else {
	    what = mons[mnum].mname;
	    if (the_unique_pm(&mons[mnum])) which = 2;
	    else if (type_is_pname(&mons[mnum])) which = 1;
	}
	if (which == 0) what = makeplural(what);
	else if (which == 2) what = the(what);

	pline("It smells like %s.", what);
	if (yn("Eat it?") == 'n') {
	    if (flags.verbose) You("discard the open tin.");
	    if (!Hallucination) tin->dknown = tin->known = 1;
	    costly_tin(COST_OPEN);
	    goto use_up_tin;
	}

	/* in case stop_occupation() was called on previous meal */
	context.victual.piece = (struct obj *)0;
	context.victual.o_id = 0;
	context.victual.fullwarn = context.victual.eating =
		context.victual.doreset = FALSE;

	You("consume %s %s.", tintxts[r].txt, mons[mnum].mname);

	eating_conducts(&mons[mnum]);

	tin->dknown = tin->known = 1;
	cprefx(mnum);
	cpostfx(mnum);

	/* charge for one at pre-eating cost */
	costly_tin(COST_OPEN);

	if (tintxts[r].nut < 0)	/* rotten */
	    make_vomiting((long)rn1(15, 10), FALSE);
	else
	    lesshungry(tintxts[r].nut);

	if (tintxts[r].greasy) {
	    /* Assume !Glib, because you can't open tins when Glib. */
	    incr_itimeout(&Glib, rnd(15));
	    pline("Eating %s food made your %s very slippery.",
		  tintxts[r].txt, makeplural(body_part(FINGER)));
	}

    } else {		/* spinach... */
	if (tin->cursed) {
	    pline("It contains some decaying%s%s substance.",
		  Blind ? "" : " ", Blind ? "" : hcolor(NH_GREEN));
	} else {
	    pline("It contains spinach.");
	    tin->dknown = tin->known = 1;
	}

	if (yn("Eat it?") == 'n') {
	    if (flags.verbose) You("discard the open tin.");
	    costly_tin(COST_OPEN);
	    goto use_up_tin;
	}

	/*
	 * Same order as with non-spinach above:
	 * conduct update, side-effects, shop handling, and nutrition.
	 */
	u.uconduct.food++; /* don't need vegan/vegetarian checks for spinach */
	if (!tin->cursed)
	    pline("This makes you feel like %s!",
		  Hallucination ? "Swee'pea" : "Popeye");
	gainstr(tin, 0, FALSE);

	costly_tin(COST_OPEN);

	lesshungry(tin->blessed ? 600 :			/* blessed */
		   !tin->cursed ? (400 + rnd(200)) :	/* uncursed */
				  (200 + rnd(400)));	/* cursed */
    }

 use_up_tin:
    if (carried(tin))
	useup(tin);
    else
	useupf(tin, 1L);
    context.tin.tin = (struct obj *)0;
    context.tin.o_id = 0;
}

STATIC_PTR
int
opentin(VOID_ARGS)		/* called during each move whilst opening a tin */
{
	/* perhaps it was stolen (although that should cause interruption) */
	if (!carried(context.tin.tin) &&
		(!obj_here(context.tin.tin, u.ux, u.uy) ||
			!can_reach_floor(TRUE)))
		return(0);		/* %% probably we should use tinoid */
	if(context.tin.usedtime++ >= 50) {
		You("give up your attempt to open the tin.");
		return(0);
	}
	if(context.tin.usedtime < context.tin.reqtime)
		return(1);		/* still busy */

	consume_tin("You succeed in opening the tin.");
	return(0);
}

STATIC_OVL void
start_tin(otmp)		/* called when starting to open a tin */
	register struct obj *otmp;
{
	const char *mesg = 0;
	register int tmp;

	if (metallivorous(youmonst.data)) {
		mesg = "You bite right into the metal tin...";
		tmp = 0;
	} else if (cantwield(youmonst.data)) {	/* nohands || verysmall */
		You("cannot handle the tin properly to open it.");
		return;
	} else if (otmp->blessed) {
		/* 50/50 chance for immediate access vs 1 turn delay (unless
		   wielding blessed tin opener which always yields immediate
		   access); 1 turn delay case is non-deterministic:  getting
		   interrupted and retrying might yield another 1 turn delay
		   or might open immediately on 2nd (or 3rd, 4th, ...) try */
		tmp = (uwep && uwep->blessed && uwep->otyp == TIN_OPENER) ? 0 :
			rn2(2);
		if (!tmp)
		    mesg = "The tin opens like magic!";
		else
		    pline_The("tin seems easy to open.");
	} else if(uwep) {
		switch(uwep->otyp) {
		case TIN_OPENER:
			mesg = "You easily open the tin."; /* iff tmp==0 */
			tmp = rn2(uwep->cursed ? 3 : !uwep->blessed ? 2 : 1);
			break;
		case DAGGER:
		case SILVER_DAGGER:
		case ELVEN_DAGGER:
		case ORCISH_DAGGER:
		case ATHAME:
		case CRYSKNIFE:
			tmp = 3;
			break;
		case PICK_AXE:
		case AXE:
			tmp = 6;
			break;
		default:
			goto no_opener;
		}
		pline("Using %s you try to open the tin.",
			yobjnam(uwep, (char *)0));
	} else {
no_opener:
		pline("It is not so easy to open this tin.");
		if(Glib) {
			pline_The("tin slips from your %s.",
			      makeplural(body_part(FINGER)));
			if(otmp->quan > 1L) {
			    otmp = splitobj(otmp, 1L);
			}
			if (carried(otmp)) dropx(otmp);
			else stackobj(otmp);
			return;
		}
		tmp = rn1(1 + 500/((int)(ACURR(A_DEX) + ACURRSTR)), 10);
	}

	context.tin.tin = otmp;
	context.tin.o_id = otmp->o_id;
	if (!tmp) {
	    consume_tin(mesg);	/* begin immediately */
	} else {
	    context.tin.reqtime = tmp;
	    context.tin.usedtime = 0;
	    set_occupation(opentin, "opening the tin", 0);
	}
	return;
}

int
Hear_again(VOID_ARGS)		/* called when waking up after fainting */
{
	/* Chance of deafness going away while fainted/sleepeing/etc. */
	if (!rn2(2))
	    set_itimeout(&HDeaf, 0L);
	return 0;
}

/* called on the "first bite" of rotten food */
STATIC_OVL int
rottenfood(obj)
struct obj *obj;
{
	pline("Blecch!  Rotten %s!", foodword(obj));
	if(!rn2(4)) {
		if (Hallucination) You_feel("rather trippy.");
		else You_feel("rather %s.", body_part(LIGHT_HEADED));
		make_confused(HConfusion + d(2,4),FALSE);
	} else if(!rn2(4) && !Blind) {
		pline("Everything suddenly goes dark.");
		make_blinded((long)d(2,10),FALSE);
		if (!Blind) Your1(vision_clears);
	} else if(!rn2(3)) {
		const char *what, *where;
		int duration = rnd(10);

		if (!Blind)
		    what = "goes",  where = "dark";
		else if (Levitation || Is_airlevel(&u.uz) ||
			 Is_waterlevel(&u.uz))
		    what = "you lose control of",  where = "yourself";
		else
		    what = "you slap against the", where =
			   (u.usteed) ? "saddle" :
			   surface(u.ux,u.uy);
		pline_The("world spins and %s %s.", what, where);
		incr_itimeout(&HDeaf, duration);
		nomul(-duration);
		multi_reason = "unconscious from rotten food";
		nomovemsg = "You are conscious again.";
		afternmv = Hear_again;
		return(1);
	}
	return(0);
}

STATIC_OVL int
eatcorpse(otmp)		/* called when a corpse is selected as food */
	register struct obj *otmp;
{
	int tp = 0, mnum = otmp->corpsenm;
	long rotted = 0L;
	int retcode = 0;
	boolean stoneable = (flesh_petrifies(&mons[mnum]) &&
				!Stone_resistance &&
				!poly_when_stoned(youmonst.data));

	/* KMH, conduct */
	if (!vegan(&mons[mnum])) u.uconduct.unvegan++;
	if (!vegetarian(&mons[mnum])) violated_vegetarian();

	if (!nonrotting_corpse(mnum)) {
		long age = peek_at_iced_corpse_age(otmp);

		rotted = (monstermoves - age)/(10L + rn2(20));
		if (otmp->cursed) rotted += 2L;
		else if (otmp->blessed) rotted -= 2L;
	}

	if (mnum != PM_ACID_BLOB && !stoneable && rotted > 5L) {
		boolean cannibal = maybe_cannibal(mnum, FALSE);
		pline("Ulch - that %s was tainted%s!",
		      mons[mnum].mlet == S_FUNGUS ? "fungoid vegetation" :
		      !vegetarian(&mons[mnum]) ? "meat" : "protoplasm",
		      cannibal ? ", you cannibal" : "");
		if (Sick_resistance) {
			pline("It doesn't seem at all sickening, though...");
		} else {
			long sick_time;

			sick_time = (long) rn1(10, 10);
			/* make sure new ill doesn't result in improvement */
			if (Sick && (sick_time > Sick))
			    sick_time = (Sick > 1L) ? Sick - 1L : 1L;
			make_sick(sick_time,
			          corpse_xname(otmp, "rotted", CXN_NORMAL),
			          TRUE, SICK_VOMITABLE);
		}
		if (carried(otmp)) useup(otmp);
		else useupf(otmp, 1L);
		return(2);
	} else if (acidic(&mons[mnum]) && !Acid_resistance) {
		tp++;
		You("have a very bad case of stomach acid."); /* not body_part() */
		losehp(rnd(15), "acidic corpse", KILLED_BY_AN); /* acid damage */
	} else if (poisonous(&mons[mnum]) && rn2(5)) {
		tp++;
		pline("Ecch - that must have been poisonous!");
		if(!Poison_resistance) {
			losestr(rnd(4));
			losehp(rnd(15), "poisonous corpse", KILLED_BY_AN);
		} else	You("seem unaffected by the poison.");
	/* now any corpse left too long will make you mildly ill */
	} else if ((rotted > 5L || (rotted > 3L && rn2(5)))
					&& !Sick_resistance) {
		tp++;
		You_feel("%ssick.", (Sick) ? "very " : "");
		losehp(rnd(8), "cadaver", KILLED_BY_AN);
	}

	/* delay is weight dependent */
	context.victual.reqtime = 3 + (mons[mnum].cwt >> 6);

	if (!tp && !nonrotting_corpse(mnum) && (otmp->orotten || !rn2(7))) {
	    if (rottenfood(otmp)) {
		otmp->orotten = TRUE;
		(void)touchfood(otmp);
		retcode = 1;
	    }

	    if (!mons[otmp->corpsenm].cnutrit) {
		/* no nutrution: rots away, no message if you passed out */
		if (!retcode) pline_The("corpse rots away completely.");
		if (carried(otmp)) useup(otmp);
		else useupf(otmp, 1L);
		retcode = 2;
	    }
		    
	    if (!retcode) consume_oeaten(otmp, 2);	/* oeaten >>= 2 */
	} else if ((mnum == PM_COCKATRICE || mnum == PM_CHICKATRICE) &&
		(Stone_resistance || Hallucination)) {
	    pline("This tastes just like chicken!");
	} else if (mnum == PM_FLOATING_EYE && u.umonnum == PM_RAVEN) {
	    You("peck the eyeball with delight.");
	} else {
	    /* [is this right?  omnivores end up always disliking the taste] */
	    boolean yummy = (vegan(&mons[mnum]) ?
				(!carnivorous(youmonst.data) &&
					herbivorous(youmonst.data)) :
				(carnivorous(youmonst.data) &&
					!herbivorous(youmonst.data)));

	    pline("%s%s %s!",
		  type_is_pname(&mons[mnum]) ? "" :
		    the_unique_pm(&mons[mnum]) ? "The " : "This ",
		  food_xname(otmp, FALSE),
		  Hallucination ?
		   (yummy ? ((u.umonnum == PM_TIGER) ? "is gr-r-reat" :
			     "is gnarly") : "is grody") :
		   (yummy ? "is delicious" : "tastes terrible"));
	}

	return(retcode);
}

STATIC_OVL void
start_eating(otmp)		/* called as you start to eat */
	register struct obj *otmp;
{
	const char *old_nomovemsg, *save_nomovemsg;

	debugpline2("start_eating: %lx (victual = %lx)",
		    (unsigned long)otmp, (unsigned long)context.victual.piece);
	debugpline1("reqtime = %d", context.victual.reqtime);
	debugpline1("(original reqtime = %d)", objects[otmp->otyp].oc_delay);
	debugpline1("nmod = %d", context.victual.nmod);
	debugpline1("oeaten = %d", otmp->oeaten);
	context.victual.fullwarn = context.victual.doreset = FALSE;
	context.victual.eating = TRUE;

	if (otmp->otyp == CORPSE || otmp->globby) {
	    cprefx(context.victual.piece->corpsenm);
	    if (!context.victual.piece || !context.victual.eating) {
		/* rider revived, or died and lifesaved */
		return;
	    }
	}

	old_nomovemsg = nomovemsg;
	if (bite()) {
	    /* survived choking, finish off food that's nearly done;
	       need this to handle cockatrice eggs, fortune cookies, etc */
	    if (++context.victual.usedtime >= context.victual.reqtime) {
		/* don't want done_eating() to issue nomovemsg if it
		   is due to vomit() called by bite() */
		save_nomovemsg = nomovemsg;
		if (!old_nomovemsg) nomovemsg = 0;
		done_eating(FALSE);
		if (!old_nomovemsg) nomovemsg = save_nomovemsg;
	    }
	    return;
	}

	if (++context.victual.usedtime >= context.victual.reqtime) {
	    /* print "finish eating" message if they just resumed -dlc */
	    done_eating(context.victual.reqtime > 1 ? TRUE : FALSE);
	    return;
	}

	Sprintf(msgbuf, "eating %s", food_xname(otmp, TRUE));
	set_occupation(eatfood, msgbuf, 0);
}


/*
 * called on "first bite" of (non-corpse) food.
 * used for non-rotten non-tin non-corpse food
 */
STATIC_OVL void
fprefx(otmp)
struct obj *otmp;
{
	switch(otmp->otyp) {
	    case FOOD_RATION:
		if(u.uhunger <= 200)
		    pline(Hallucination ? "Oh wow, like, superior, man!" :
			  "That food really hit the spot!");
		else if(u.uhunger <= 700) pline("That satiated your %s!",
						body_part(STOMACH));
		break;
	    case TRIPE_RATION:
		if (carnivorous(youmonst.data) && !humanoid(youmonst.data))
		    pline("That tripe ration was surprisingly good!");
		else if (maybe_polyd(is_orc(youmonst.data), Race_if(PM_ORC)))
		    pline(Hallucination ? "Tastes great! Less filling!" :
			  "Mmm, tripe... not bad!");
		else {
		    pline("Yak - dog food!");
		    more_experienced(1,0);
		    newexplevel();
		    /* not cannibalism, but we use similar criteria
		       for deciding whether to be sickened by this meal */
		    if (rn2(2) && !CANNIBAL_ALLOWED())
			make_vomiting((long)rn1(context.victual.reqtime, 14), FALSE);
		}
		break;
	    case MEATBALL:
	    case MEAT_STICK:
	    case HUGE_CHUNK_OF_MEAT:
	    case MEAT_RING:
		goto give_feedback;
	     /* break; */
	    case CLOVE_OF_GARLIC:
		if (is_undead(youmonst.data)) {
			make_vomiting((long)rn1(context.victual.reqtime, 5), FALSE);
			break;
		}
		/* Fall through otherwise */
	    default:
		if (otmp->otyp == SLIME_MOLD && !otmp->cursed &&
			otmp->spe == context.current_fruit)
		    pline("My, that was a %s %s!",
			  Hallucination ? "primo" : "yummy",
			  singular(otmp, xname));
		else if (otmp->otyp == APPLE && otmp->cursed &&
			!Sleep_resistance)
		    ;	/* skip core joke; feedback deferred til fpostfx() */
		else
#ifdef UNIX
		if (otmp->otyp == APPLE || otmp->otyp == PEAR) {
		    if (!Hallucination) {
			pline("Core dumped.");
		    } else {
/* This is based on an old Usenet joke, a fake a.out manual page */
			int x = rnd(100);
			if (x <= 75)
			    pline("Segmentation fault -- core dumped.");
			else if (x <= 99)
			    pline("Bus error -- core dumped.");
			else pline("Yo' mama -- core dumped.");
		    }
		} else
#endif
#if defined(MAC) || defined(MACOSX)	/* KMH -- Why should Unix have all the fun? */
		if (otmp->otyp == APPLE) {
			pline("Delicious!  Must be a Macintosh!");
		} else
#endif
		if (otmp->otyp == EGG && stale_egg(otmp)) {
		    pline("Ugh.  Rotten egg.");	/* perhaps others like it */
		    make_vomiting((Vomiting & TIMEOUT) + (long)d(10,4), TRUE);
		} else
 give_feedback:
		    pline("This %s is %s", singular(otmp, xname),
		      otmp->cursed ? (Hallucination ? "grody!" : "terrible!") :
		      (otmp->otyp == CRAM_RATION
		      || otmp->otyp == K_RATION
		      || otmp->otyp == C_RATION)
		      ? "bland." :
		      Hallucination ? "gnarly!" : "delicious!");
		break;
	}
}

/* increment a combat intrinsic with limits on its growth */
STATIC_OVL int
bounded_increase(old, inc, typ)
int old, inc, typ;
{
    int absold, absinc, sgnold, sgninc;

    /* don't include any amount coming from worn rings */
    if (uright && uright->otyp == typ) old -= uright->spe;
    if (uleft && uleft->otyp == typ) old -= uleft->spe;
    absold = abs(old), absinc = abs(inc);
    sgnold = sgn(old), sgninc = sgn(inc);

    if (absinc == 0 || sgnold != sgninc || absold + absinc < 10) {
	;	/* use inc as-is */
    } else if (absold + absinc < 20) {
	absinc = rnd(absinc);	/* 1..n */
	if (absold + absinc < 10) absinc = 10 - absold;
	inc = sgninc * absinc;
    } else if (absold + absinc < 40) {
	absinc = rn2(absinc) ? 1 : 0;
	if (absold + absinc < 20) absinc = rnd(20 - absold);
	inc = sgninc * absinc;
    } else {
	inc = 0;	/* no further increase allowed via this method */
    }
    return old + inc;
}

STATIC_OVL void
accessory_has_effect(otmp)
struct obj *otmp;
{
	pline("Magic spreads through your body as you digest the %s.",
	    otmp->oclass == RING_CLASS ? "ring" : "amulet");
}

STATIC_OVL void
eataccessory(otmp)
struct obj *otmp;
{
	int typ = otmp->otyp;
	long oldprop;

	/* Note: rings are not so common that this is unbalancing. */
	/* (How often do you even _find_ 3 rings of polymorph in a game?) */
	oldprop = u.uprops[objects[typ].oc_oprop].intrinsic;
	if (otmp == uleft || otmp == uright) {
	    Ring_gone(otmp);
	    if (u.uhp <= 0) return; /* died from sink fall */
	}
	otmp->known = otmp->dknown = 1; /* by taste */
	if (!rn2(otmp->oclass == RING_CLASS ? 3 : 5)) {
	  switch (otmp->otyp) {
	    default:
	        if (!objects[typ].oc_oprop) break; /* should never happen */

		if (!(u.uprops[objects[typ].oc_oprop].intrinsic & FROMOUTSIDE))
		    accessory_has_effect(otmp);

		u.uprops[objects[typ].oc_oprop].intrinsic |= FROMOUTSIDE;

		switch (typ) {
		  case RIN_SEE_INVISIBLE:
		    set_mimic_blocking();
		    see_monsters();
		    if (Invis && !oldprop && !ESee_invisible &&
				!perceives(youmonst.data) && !Blind) {
			newsym(u.ux,u.uy);
			pline("Suddenly you can see yourself.");
			makeknown(typ);
		    }
		    break;
		  case RIN_INVISIBILITY:
		    if (!oldprop && !EInvis && !BInvis &&
					!See_invisible && !Blind) {
			newsym(u.ux,u.uy);
			Your("body takes on a %s transparency...",
				Hallucination ? "normal" : "strange");
			makeknown(typ);
		    }
		    break;
		  case RIN_PROTECTION_FROM_SHAPE_CHAN:
		    rescham();
		    break;
		  case RIN_LEVITATION:
		    /* undo the `.intrinsic |= FROMOUTSIDE' done above */
		    u.uprops[LEVITATION].intrinsic = oldprop;
		    if (!Levitation) {
			float_up();
			incr_itimeout(&HLevitation, d(10,20));
			makeknown(typ);
		    }
		    break;
		}
		break;
	    case RIN_ADORNMENT:
		accessory_has_effect(otmp);
		if (adjattrib(A_CHA, otmp->spe, -1))
		    makeknown(typ);
		break;
	    case RIN_GAIN_STRENGTH:
		accessory_has_effect(otmp);
		if (adjattrib(A_STR, otmp->spe, -1))
		    makeknown(typ);
		break;
	    case RIN_GAIN_CONSTITUTION:
		accessory_has_effect(otmp);
		if (adjattrib(A_CON, otmp->spe, -1))
		    makeknown(typ);
		break;
	    case RIN_INCREASE_ACCURACY:
		accessory_has_effect(otmp);
		u.uhitinc = (schar)bounded_increase((int)u.uhitinc, otmp->spe,
						    RIN_INCREASE_ACCURACY);
		break;
	    case RIN_INCREASE_DAMAGE:
		accessory_has_effect(otmp);
		u.udaminc = (schar)bounded_increase((int)u.udaminc, otmp->spe,
						    RIN_INCREASE_DAMAGE);
		break;
	    case RIN_PROTECTION:
		accessory_has_effect(otmp);
		HProtection |= FROMOUTSIDE;
		u.ublessed = bounded_increase(u.ublessed, otmp->spe,
					      RIN_PROTECTION);
		context.botl = 1;
		break;
	    case RIN_FREE_ACTION:
		/* Give sleep resistance instead */
		if (!(HSleep_resistance & FROMOUTSIDE))
		    accessory_has_effect(otmp);
		if (!Sleep_resistance)
		    You_feel("wide awake.");
		HSleep_resistance |= FROMOUTSIDE;
		break;
	    case AMULET_OF_CHANGE:
		accessory_has_effect(otmp);
		makeknown(typ);
		change_sex();
		You("are suddenly very %s!",
		    flags.female ? "feminine" : "masculine");
		context.botl = 1;
		break;
	    case AMULET_OF_UNCHANGING:
		/* un-change: it's a pun */
		if (!Unchanging && Upolyd) {
		    accessory_has_effect(otmp);
		    makeknown(typ);
		    rehumanize();
		}
		break;
	    case AMULET_OF_STRANGULATION: /* bad idea! */
		/* no message--this gives no permanent effect */
		choke(otmp);
		break;
	    case AMULET_OF_RESTFUL_SLEEP: /* another bad idea! */
	      {
		long newnap = (long)rnd(100), oldnap = (HSleepy & TIMEOUT);

		if (!(HSleepy & FROMOUTSIDE))
		    accessory_has_effect(otmp);
		HSleepy |= FROMOUTSIDE;
		/* might also be wearing one; use shorter of two timeouts */
		if (newnap < oldnap || oldnap == 0L)
		    HSleepy = (HSleepy & ~TIMEOUT) | newnap;
	      }
		break;
	    case RIN_SUSTAIN_ABILITY:
	    case AMULET_OF_LIFE_SAVING:
	    case AMULET_OF_REFLECTION: /* nice try */
	    /* can't eat Amulet of Yendor or fakes,
	     * and no oc_prop even if you could -3.
	     */
		break;
	  }
	}
}

STATIC_OVL void
eatspecial() /* called after eating non-food */
{
	register struct obj *otmp = context.victual.piece;

	/* lesshungry wants an occupation to handle choke messages correctly */
	set_occupation(eatfood, "eating non-food", 0);
	lesshungry(context.victual.nmod);
	occupation = 0;
	context.victual.piece = (struct obj *)0;
	context.victual.o_id = 0;
	context.victual.eating = 0;
	if (otmp->oclass == COIN_CLASS) {
		if (carried(otmp))
		    useupall(otmp);
		else
		    useupf(otmp, otmp->quan);
		vault_gd_watching(GD_EATGOLD);
		return;
	}
#ifdef MAIL
	if (otmp->otyp == SCR_MAIL) {
		/* no nutrition */
		pline("This junk mail is less than satisfying.");
	}
#endif
	if (otmp->oclass == POTION_CLASS) {
		otmp->quan++; /* dopotion() does a useup() */
		(void)dopotion(otmp);
	}
	if (otmp->oclass == RING_CLASS || otmp->oclass == AMULET_CLASS)
		eataccessory(otmp);
	else if (otmp->otyp == LEASH && otmp->leashmon)
		o_unleash(otmp);

	/* KMH -- idea by "Tommy the Terrorist" */
	if ((otmp->otyp == TRIDENT) && !otmp->cursed)
	{
		pline(Hallucination ? "Four out of five dentists agree." :
				"That was pure chewing satisfaction!");
		exercise(A_WIS, TRUE);
	}
	if ((otmp->otyp == FLINT) && !otmp->cursed)
	{
		pline("Yabba-dabba delicious!");
		exercise(A_CON, TRUE);
	}

	if (otmp == uwep && otmp->quan == 1L) uwepgone();
	if (otmp == uquiver && otmp->quan == 1L) uqwepgone();
	if (otmp == uswapwep && otmp->quan == 1L) uswapwepgone();

	if (otmp == uball) unpunish();
	if (otmp == uchain) unpunish(); /* but no useup() */
	else if (carried(otmp)) useup(otmp);
	else useupf(otmp, 1L);
}

/* NOTE: the order of these words exactly corresponds to the
   order of oc_material values #define'd in objclass.h. */
static const char *foodwords[] = {
	"meal", "liquid", "wax", "food", "meat",
	"paper", "cloth", "leather", "wood", "bone", "scale",
	"metal", "metal", "metal", "silver", "gold", "platinum", "mithril",
	"plastic", "glass", "rich food", "stone"
};

STATIC_OVL const char *
foodword(otmp)
register struct obj *otmp;
{
	if (otmp->oclass == FOOD_CLASS) return "food";
	if (otmp->oclass == GEM_CLASS &&
	    objects[otmp->otyp].oc_material == GLASS &&
	    otmp->dknown)
		makeknown(otmp->otyp);
	return foodwords[objects[otmp->otyp].oc_material];
}

STATIC_OVL void
fpostfx(otmp)		/* called after consuming (non-corpse) food */
register struct obj *otmp;
{
	switch(otmp->otyp) {
	    case SPRIG_OF_WOLFSBANE:
		if (u.ulycn >= LOW_PM || is_were(youmonst.data))
		    you_unwere(TRUE);
		break;
	    case CARROT:
		if (!u.uswallow ||
		    !attacktype_fordmg(u.ustuck->data, AT_ENGL, AD_BLND))
		    make_blinded((long)u.ucreamed,TRUE);
		break;
	    case FORTUNE_COOKIE:
		outrumor(bcsign(otmp), BY_COOKIE);
		if (!Blind) u.uconduct.literate++;
		break;
	    case LUMP_OF_ROYAL_JELLY:
		/* This stuff seems to be VERY healthy! */
		gainstr(otmp, 1, TRUE);
		if (Upolyd) {
		    u.mh += otmp->cursed ? -rnd(20) : rnd(20);
		    if (u.mh > u.mhmax) {
			if (!rn2(17)) u.mhmax++;
			u.mh = u.mhmax;
		    } else if (u.mh <= 0) {
			rehumanize();
		    }
		} else {
		    u.uhp += otmp->cursed ? -rnd(20) : rnd(20);
		    if (u.uhp > u.uhpmax) {
			if(!rn2(17)) u.uhpmax++;
			u.uhp = u.uhpmax;
		    } else if (u.uhp <= 0) {
			killer.format = KILLED_BY_AN;
			Strcpy(killer.name, "rotten lump of royal jelly");
			done(POISONING);
		    }
		}
		if(!otmp->cursed) heal_legs();
		break;
	    case EGG:
		if (flesh_petrifies(&mons[otmp->corpsenm])) {
		    if (!Stone_resistance &&
			!(poly_when_stoned(youmonst.data) &&
			    polymon(PM_STONE_GOLEM))) {
			if (!Stoned) {
			    Sprintf(killer.name,
				    "%s egg", mons[otmp->corpsenm].mname);
			    make_stoned(5L, (char *)0,
					KILLED_BY_AN, killer.name);
			}
		    }
		    /* note: no "tastes like chicken" message for eggs */
		}
		break;
	    case EUCALYPTUS_LEAF:
		if (Sick && !otmp->cursed)
		    make_sick(0L, (char *)0, TRUE, SICK_ALL);
		if (Vomiting && !otmp->cursed)
		    make_vomiting(0L, TRUE);
		break;
	    case APPLE:
		if (otmp->cursed && !Sleep_resistance) {
		    /* Snow White; 'poisoned' applies to [a subset of] weapons,
		       not food, so we substitute cursed; fortunately our hero
		       won't have to wait for a prince to be rescued/revived */
		    if (Race_if(PM_DWARF) && Hallucination)
			verbalize("Heigh-ho, ho-hum, I think I'll skip work today.");
		    else if (Deaf || !flags.acoustics)
			You("fall asleep.");
		    else
			You_hear("sinister laughter as you fall asleep...");
		    fall_asleep(-rn1(11, 20), TRUE);
		}
		break;
	}
	return;
}

#if 0
/* intended for eating a spellbook while polymorphed, but not used;
   "leather" applied to appearance, not composition, and has been
   changed to "leathery" to reflect that */
STATIC_DCL boolean FDECL(leather_cover, (struct obj *));

STATIC_OVL boolean
leather_cover(otmp)
struct obj *otmp;
{
	const char *odesc = OBJ_DESCR(objects[otmp->otyp]);

	if (odesc && (otmp->oclass == SPBOOK_CLASS)) {
		if (!strcmp(odesc, "leather"))
			return TRUE;
	}
	return FALSE;
}
#endif

/*
 * return 0 if the food was not dangerous.
 * return 1 if the food was dangerous and you chose to stop.
 * return 2 if the food was dangerous and you chose to eat it anyway.
 */
STATIC_OVL int
edibility_prompts(otmp)
struct obj *otmp;
{
	/* blessed food detection granted you a one-use
	   ability to detect food that is unfit for consumption
	   or dangerous and avoid it. */

	char buf[BUFSZ], foodsmell[BUFSZ],
	     it_or_they[QBUFSZ], eat_it_anyway[QBUFSZ];
	boolean cadaver = (otmp->otyp == CORPSE),
		stoneorslime = FALSE;
	int material = objects[otmp->otyp].oc_material,
	    mnum = otmp->corpsenm;
	long rotted = 0L;

	Strcpy(foodsmell, Tobjnam(otmp, "smell"));
	Strcpy(it_or_they, (otmp->quan == 1L) ? "it" : "they");
	Sprintf(eat_it_anyway, "Eat %s anyway?",
		(otmp->quan == 1L) ? "it" : "one");

	if (cadaver || otmp->otyp == EGG || otmp->otyp == TIN) {
		/* These checks must match those in eatcorpse() */
		stoneorslime = (flesh_petrifies(&mons[mnum]) &&
				!Stone_resistance &&
				!poly_when_stoned(youmonst.data));

		if (mnum == PM_GREEN_SLIME || otmp->otyp == GLOB_OF_GREEN_SLIME)
		    stoneorslime = (!Unchanging && !slimeproof(youmonst.data));

		if (cadaver && !nonrotting_corpse(mnum)) {
			long age = peek_at_iced_corpse_age(otmp);
			/* worst case rather than random
			   in this calculation to force prompt */
			rotted = (monstermoves - age)/(10L + 0 /* was rn2(20) */);
			if (otmp->cursed) rotted += 2L;
			else if (otmp->blessed) rotted -= 2L;
		}
	}

	/*
	 * These problems with food should be checked in
	 * order from most detrimental to least detrimental.
	 */

	if (cadaver && mnum != PM_ACID_BLOB && rotted > 5L && !Sick_resistance) {
		/* Tainted meat */
		Sprintf(buf, "%s like %s could be tainted! %s",
			foodsmell, it_or_they, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	if (stoneorslime) {
		Sprintf(buf, "%s like %s could be something very dangerous! %s",
			foodsmell, it_or_they, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	if (otmp->orotten || (cadaver && rotted > 3L)) {
		/* Rotten */
		Sprintf(buf, "%s like %s could be rotten! %s",
			foodsmell, it_or_they, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	if (cadaver && poisonous(&mons[mnum]) && !Poison_resistance) {
		/* poisonous */
		Sprintf(buf, "%s like %s might be poisonous! %s",
			foodsmell, it_or_they, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	if (otmp->otyp == APPLE && otmp->cursed && !Sleep_resistance) {
		/* causes sleep, for long enough to be dangerous */
		Sprintf(buf, "%s like %s might have been poisoned. %s",
			foodsmell, it_or_they, eat_it_anyway);
		return (yn_function(buf, ynchars, 'n') == 'n') ? 1 : 2;
	}
	if (cadaver && !vegetarian(&mons[mnum]) &&
	    !u.uconduct.unvegetarian && Role_if(PM_MONK)) {
		Sprintf(buf, "%s unhealthy. %s",
			foodsmell, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	if (cadaver && acidic(&mons[mnum]) && !Acid_resistance) {
		Sprintf(buf, "%s rather acidic. %s",
			foodsmell, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	if (Upolyd && u.umonnum == PM_RUST_MONSTER &&
	    is_metallic(otmp) && otmp->oerodeproof) {
		Sprintf(buf, "%s disgusting to you right now. %s",
			foodsmell, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}

	/*
	 * Breaks conduct, but otherwise safe.
	 */
	 
	if (!u.uconduct.unvegan &&
	    ((material == LEATHER || material == BONE ||
	      material == DRAGON_HIDE || material == WAX) ||
	     (cadaver && !vegan(&mons[mnum])))) {
		Sprintf(buf, "%s foul and unfamiliar to you. %s",
			foodsmell, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	if (!u.uconduct.unvegetarian &&
	    ((material == LEATHER || material == BONE ||
	      material == DRAGON_HIDE) ||
	     (cadaver && !vegetarian(&mons[mnum])))) {
		Sprintf(buf, "%s unfamiliar to you. %s",
			foodsmell, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}

	if (cadaver && mnum != PM_ACID_BLOB && rotted > 5L && Sick_resistance) {
		/* Tainted meat with Sick_resistance */
		Sprintf(buf, "%s like %s could be tainted! %s",
			foodsmell, it_or_they, eat_it_anyway);
		if (yn_function(buf,ynchars,'n')=='n') return 1;
		else return 2;
	}
	return 0;
}

int
doeat()		/* generic "eat" command funtion (see cmd.c) */
{
	struct obj *otmp;
	int basenutrit;			/* nutrition of full item */
	boolean dont_start = FALSE, nodelicious = FALSE;
	
	if (Strangled) {
		pline("If you can't breathe air, how can you consume solids?");
		return 0;
	}
	if (!(otmp = floorfood("eat", 0))) return 0;
	if (check_capacity((char *)0)) return 0;

	if (u.uedibility) {
		int res = edibility_prompts(otmp);
		if (res) {
		    Your("%s stops tingling and your sense of smell returns to normal.",
			body_part(NOSE));
		    u.uedibility = 0;
		    if (res == 1) return 0;
		}
	}

	/* We have to make non-foods take 1 move to eat, unless we want to
	 * do ridiculous amounts of coding to deal with partly eaten plate
	 * mails, players who polymorph back to human in the middle of their
	 * metallic meal, etc....
	 */
	if (!(carried(otmp) ? retouch_object(&otmp, FALSE) :
			      touch_artifact(otmp, &youmonst))) {
	    return 1;
	} else if (!is_edible(otmp)) {
	    You("cannot eat that!");
	    return 0;
	} else if ((otmp->owornmask & (W_ARMOR|W_TOOL|W_AMUL|W_SADDLE)) != 0) {
	    /* let them eat rings */
	    You_cant("eat %s you're wearing.", something);
	    return 0;
	}
	if (is_metallic(otmp) &&
	    u.umonnum == PM_RUST_MONSTER && otmp->oerodeproof) {
	    	otmp->rknown = TRUE;
		if (otmp->quan > 1L) {
		    if(!carried(otmp))
			(void) splitobj(otmp, otmp->quan - 1L);
		    else
			otmp = splitobj(otmp, 1L);
		}
		pline("Ulch - that %s was rustproofed!", xname(otmp));
		/* The regurgitated object's rustproofing is gone now */
		otmp->oerodeproof = 0;
		make_stunned((HStun & TIMEOUT) + (long)rn2(10), TRUE);
		You("spit %s out onto the %s.", the(xname(otmp)),
			surface(u.ux, u.uy));
		if (carried(otmp)) {
			freeinv(otmp);
			dropy(otmp);
		}
		stackobj(otmp);
		return 1;
	}
	/* KMH -- Slow digestion is... indigestible */
	if (otmp->otyp == RIN_SLOW_DIGESTION) {
		pline("This ring is indigestible!");
		(void) rottenfood(otmp);
		if (otmp->dknown && !objects[otmp->otyp].oc_name_known
				&& !objects[otmp->otyp].oc_uname)
			docall(otmp);
		return (1);
	}
	if (otmp->oclass != FOOD_CLASS) {
	    int material;
	    context.victual.reqtime = 1;
	    context.victual.piece = otmp;
	    context.victual.o_id = otmp->o_id;
		/* Don't split it, we don't need to if it's 1 move */
	    context.victual.usedtime = 0;
	    context.victual.canchoke = (u.uhs == SATIATED);
		/* Note: gold weighs 1 pt. for each 1000 pieces (see */
		/* pickup.c) so gold and non-gold is consistent. */
	    if (otmp->oclass == COIN_CLASS)
		basenutrit = ((otmp->quan > 200000L) ? 2000
			: (int)(otmp->quan/100L));
	    else if(otmp->oclass == BALL_CLASS || otmp->oclass == CHAIN_CLASS)
		basenutrit = weight(otmp);
	    /* oc_nutrition is usually weight anyway */
	    else basenutrit = objects[otmp->otyp].oc_nutrition;
#ifdef MAIL
	    if (otmp->otyp == SCR_MAIL) {
		basenutrit = 0;
		nodelicious = TRUE;
	    }
#endif
	    context.victual.nmod = basenutrit;
	    context.victual.eating = TRUE; /* needed for lesshungry() */

	    material = objects[otmp->otyp].oc_material;
	    if (material == LEATHER ||
		material == BONE || material == DRAGON_HIDE) {
		u.uconduct.unvegan++;
		violated_vegetarian();
	    } else if (material == WAX)
		u.uconduct.unvegan++;
	    u.uconduct.food++;
	    
	    if (otmp->cursed)
		(void) rottenfood(otmp);

	    if (otmp->oclass == WEAPON_CLASS && otmp->opoisoned) {
		pline("Ecch - that must have been poisonous!");
		if(!Poison_resistance) {
		    losestr(rnd(4));
		    losehp(rnd(15), xname(otmp), KILLED_BY_AN);
		} else
		    You("seem unaffected by the poison.");
	    } else if (!otmp->cursed && !nodelicious)
		pline("%s%s is delicious!",
		      (obj_is_pname(otmp) &&
		       (otmp->oartifact < ART_ORB_OF_DETECTION)) ? "" : "This ",
		      otmp->oclass == COIN_CLASS ? foodword(otmp) :
		      singular(otmp, xname));

	    eatspecial();
	    return 1;
	}

	if(otmp == context.victual.piece) {
	/* If they weren't able to choke, they don't suddenly become able to
	 * choke just because they were interrupted.  On the other hand, if
	 * they were able to choke before, if they lost food it's possible
	 * they shouldn't be able to choke now.
	 */
	    if (u.uhs != SATIATED) context.victual.canchoke = FALSE;
	    context.victual.o_id = 0;
	    context.victual.piece = touchfood(otmp);
	    if (context.victual.piece)
	    	context.victual.o_id = context.victual.piece->o_id;
	    You("resume your meal.");
	    start_eating(context.victual.piece);
	    return(1);
	}

	/* nothing in progress - so try to find something. */
	/* tins are a special case */
	/* tins must also check conduct separately in case they're discarded */
	if(otmp->otyp == TIN) {
	    start_tin(otmp);
	    return(1);
	}

	/* KMH, conduct */
	u.uconduct.food++;

	context.victual.o_id = 0;
	context.victual.piece = otmp = touchfood(otmp);
	if (context.victual.piece)
		context.victual.o_id = context.victual.piece->o_id;
	context.victual.usedtime = 0;

	/* Now we need to calculate delay and nutritional info.
	 * The base nutrition calculated here and in eatcorpse() accounts
	 * for normal vs. rotten food.  The reqtime and nutrit values are
	 * then adjusted in accordance with the amount of food left.
	 */
	if(otmp->otyp == CORPSE || otmp->globby) {
	    int tmp = eatcorpse(otmp);
	    if (tmp == 2) {
		/* used up */
		context.victual.piece = (struct obj *)0;
		context.victual.o_id = 0;
		return(1);
	    } else if (tmp)
		dont_start = TRUE;
	    /* if not used up, eatcorpse sets up reqtime and may modify
	     * oeaten */
	} else {
	    /* No checks for WAX, LEATHER, BONE, DRAGON_HIDE.  These are
	     * all handled in the != FOOD_CLASS case, above */
	    switch (objects[otmp->otyp].oc_material) {
	    case FLESH:
		u.uconduct.unvegan++;
		if (otmp->otyp != EGG) {
		    violated_vegetarian();
		}
		break;

	    default:
		if (otmp->otyp == PANCAKE ||
		    otmp->otyp == FORTUNE_COOKIE || /* eggs */
		    otmp->otyp == CREAM_PIE ||
		    otmp->otyp == CANDY_BAR || /* milk */
		    otmp->otyp == LUMP_OF_ROYAL_JELLY)
		    u.uconduct.unvegan++;
		break;
	    }

	    context.victual.reqtime = objects[otmp->otyp].oc_delay;
	    if (otmp->otyp != FORTUNE_COOKIE &&
		(otmp->cursed || (!nonrotting_food(otmp->otyp) &&
		    (monstermoves - otmp->age) > (otmp->blessed ? 50L : 30L) &&
		    (otmp->orotten || !rn2(7))))) {

		if (rottenfood(otmp)) {
		    otmp->orotten = TRUE;
		    dont_start = TRUE;
		}
		consume_oeaten(otmp, 1);	/* oeaten >>= 1 */
	    } else
		fprefx(otmp);
	}

	/* re-calc the nutrition */
	if (otmp->otyp == CORPSE) basenutrit = mons[otmp->corpsenm].cnutrit;
	else basenutrit = objects[otmp->otyp].oc_nutrition;

	debugpline1("before rounddiv: context.victual.reqtime == %d",
		    context.victual.reqtime);
	debugpline2("oeaten == %d, basenutrit == %d",
		    otmp->oeaten, basenutrit);
	context.victual.reqtime = (basenutrit == 0 ? 0 :
		rounddiv(context.victual.reqtime * (long)otmp->oeaten, basenutrit));
	debugpline1("after rounddiv: context.victual.reqtime == %d",
		    context.victual.reqtime);
	/* calculate the modulo value (nutrit. units per round eating)
	 * note: this isn't exact - you actually lose a little nutrition
	 *	 due to this method.
	 * TODO: add in a "remainder" value to be given at the end of the
	 *	 meal.
	 */
	if (context.victual.reqtime == 0 || otmp->oeaten == 0)
	    /* possible if most has been eaten before */
	    context.victual.nmod = 0;
	else if ((int)otmp->oeaten >= context.victual.reqtime)
	    context.victual.nmod = -((int)otmp->oeaten / context.victual.reqtime);
	else
	    context.victual.nmod = context.victual.reqtime % otmp->oeaten;
	context.victual.canchoke = (u.uhs == SATIATED);

	if (!dont_start) start_eating(otmp);
	return(1);
}

/* Take a single bite from a piece of food, checking for choking and
 * modifying usedtime.  Returns 1 if they choked and survived, 0 otherwise.
 */
STATIC_OVL int
bite()
{
	if(context.victual.canchoke && u.uhunger >= 2000) {
		choke(context.victual.piece);
		return 1;
	}
	if (context.victual.doreset) {
		do_reset_eat();
		return 0;
	}
	force_save_hs = TRUE;
	if(context.victual.nmod < 0) {
		lesshungry(-context.victual.nmod);
		consume_oeaten(context.victual.piece, context.victual.nmod); /* -= -nmod */
	} else if(context.victual.nmod > 0 && (context.victual.usedtime % context.victual.nmod)) {
		lesshungry(1);
		consume_oeaten(context.victual.piece, -1);		  /* -= 1 */
	}
	force_save_hs = FALSE;
	recalc_wt();
	return 0;
}

void
gethungry()	/* as time goes by - called by moveloop() and domove() */
{
	if (u.uinvulnerable) return;	/* you don't feel hungrier */

	if ((!u.usleep || !rn2(10))	/* slow metabolic rate while asleep */
		&& (carnivorous(youmonst.data) || herbivorous(youmonst.data))
		&& !Slow_digestion)
	    u.uhunger--;		/* ordinary food consumption */

	if (moves % 2) {	/* odd turns */
	    /* Regeneration uses up food, unless due to an artifact */
	    if ((HRegeneration & ~FROMFORM) ||
		    (ERegeneration & ~(W_ARTI|W_WEP))) u.uhunger--;
	    if (near_capacity() > SLT_ENCUMBER) u.uhunger--;
	} else {		/* even turns */
	    if (Hunger) u.uhunger--;
	    /* Conflict uses up food too */
	    if (HConflict || (EConflict & (~W_ARTI))) u.uhunger--;
	    /* +0 charged rings don't do anything, so don't affect hunger */
	    /* Slow digestion still uses ring hunger */
	    switch ((int)(moves % 20)) {	/* note: use even cases only */
	     case  4: if (uleft &&
			  (uleft->spe || !objects[uleft->otyp].oc_charged))
			    u.uhunger--;
		    break;
	     case  8: if (uamul) u.uhunger--;
		    break;
	     case 12: if (uright &&
			  (uright->spe || !objects[uright->otyp].oc_charged))
			    u.uhunger--;
		    break;
	     case 16: if (u.uhave.amulet) u.uhunger--;
		    break;
	     default: break;
	    }
	}
	newuhs(TRUE);
}

void
morehungry(num)	/* called after vomiting and after performing feats of magic */
register int num;
{
	u.uhunger -= num;
	newuhs(TRUE);
}


void
lesshungry(num)	/* called after eating (and after drinking fruit juice) */
register int num;
{
	/* See comments in newuhs() for discussion on force_save_hs */
	boolean iseating = (occupation == eatfood) || force_save_hs;
	debugpline1("lesshungry(%d)", num);
	u.uhunger += num;
	if(u.uhunger >= 2000) {
	    if (!iseating || context.victual.canchoke) {
		if (iseating) {
		    choke(context.victual.piece);
		    reset_eat();
		} else
		    choke(occupation == opentin ? context.tin.tin : (struct obj *)0);
		/* no reset_eat() */
	    }
	} else {
	    /* Have lesshungry() report when you're nearly full so all eating
	     * warns when you're about to choke.
	     */
	    if (u.uhunger >= 1500) {
		if (!context.victual.eating || (context.victual.eating && !context.victual.fullwarn)) {
		    pline("You're having a hard time getting all of it down.");
		    nomovemsg = "You're finally finished.";
		    if (!context.victual.eating)
			multi = -2;
		    else {
			context.victual.fullwarn = TRUE;
			if (context.victual.canchoke && context.victual.reqtime > 1) {
			    /* a one-gulp food will not survive a stop */
			    if (yn_function("Continue eating?",
						ynchars,'n') != 'y') {
				reset_eat();
				nomovemsg = (char *)0;
			    }
			}
		    }
		}
	    }
	}
	newuhs(FALSE);
}

STATIC_PTR
int
unfaint(VOID_ARGS)
{
	(void) Hear_again();
	if(u.uhs > FAINTING)
		u.uhs = FAINTING;
	stop_occupation();
	context.botl = 1;
	return 0;
}

boolean
is_fainted()
{
	return((boolean)(u.uhs == FAINTED));
}

void
reset_faint()	/* call when a faint must be prematurely terminated */
{
	if (afternmv == unfaint) unmul("You revive.");
}

void
newuhs(incr)		/* compute and comment on your (new?) hunger status */
boolean incr;
{
	unsigned newhs;
	static unsigned save_hs;
	static boolean saved_hs = FALSE;
	int h = u.uhunger;

	newhs = (h > 1000) ? SATIATED :
		(h > 150) ? NOT_HUNGRY :
		(h > 50) ? HUNGRY :
		(h > 0) ? WEAK : FAINTING;

	/* While you're eating, you may pass from WEAK to HUNGRY to NOT_HUNGRY.
	 * This should not produce the message "you only feel hungry now";
	 * that message should only appear if HUNGRY is an endpoint.  Therefore
	 * we check to see if we're in the middle of eating.  If so, we save
	 * the first hunger status, and at the end of eating we decide what
	 * message to print based on the _entire_ meal, not on each little bit.
	 */
	/* It is normally possible to check if you are in the middle of a meal
	 * by checking occupation == eatfood, but there is one special case:
	 * start_eating() can call bite() for your first bite before it
	 * sets the occupation.
	 * Anyone who wants to get that case to work _without_ an ugly static
	 * force_save_hs variable, feel free.
	 */
	/* Note: If you become a certain hunger status in the middle of the
	 * meal, and still have that same status at the end of the meal,
	 * this will incorrectly print the associated message at the end of
	 * the meal instead of the middle.  Such a case is currently
	 * impossible, but could become possible if a message for SATIATED
	 * were added or if HUNGRY and WEAK were separated by a big enough
	 * gap to fit two bites.
	 */
	if (occupation == eatfood || force_save_hs) {
		if (!saved_hs) {
			save_hs = u.uhs;
			saved_hs = TRUE;
		}
		u.uhs = newhs;
		return;
	} else {
		if (saved_hs) {
			u.uhs = save_hs;
			saved_hs = FALSE;
		}
	}

	if(newhs == FAINTING) {
		if(is_fainted()) newhs = FAINTED;
		if(u.uhs <= WEAK || rn2(20-u.uhunger/10) >= 19) {
			if(!is_fainted() && multi >= 0 /* %% */) {
				int duration = 10-(u.uhunger/10);

				/* stop what you're doing, then faint */
				stop_occupation();
				You("faint from lack of food.");
				if (!Levitation) selftouch("Falling, you");
				incr_itimeout(&HDeaf, duration);
				nomul(-duration);
				multi_reason = "fainted from lack of food";
				nomovemsg = "You regain consciousness.";
				afternmv = unfaint;
				newhs = FAINTED;
			}
		} else
		if(u.uhunger < -(int)(200 + 20*ACURR(A_CON))) {
			u.uhs = STARVED;
			context.botl = 1;
			bot();
			You("die from starvation.");
			killer.format = KILLED_BY;
			Strcpy(killer.name, "starvation");
			done(STARVING);
			/* if we return, we lifesaved, and that calls newuhs */
			return;
		}
	}

	if(newhs != u.uhs) {
		if(newhs >= WEAK && u.uhs < WEAK)
			losestr(1);	/* this may kill you -- see below */
		else if(newhs < WEAK && u.uhs >= WEAK)
			losestr(-1);
		switch(newhs){
		case HUNGRY:
			if (Hallucination) {
			    You((!incr) ?
				"now have a lesser case of the munchies." :
				"are getting the munchies.");
			} else
			    You((!incr) ? "only feel hungry now." :
				  (u.uhunger < 145) ? "feel hungry." :
				   "are beginning to feel hungry.");
			if (incr && occupation &&
			    (occupation != eatfood && occupation != opentin))
			    stop_occupation();
			context.travel = context.travel1 = context.mv = context.run = 0;
			break;
		case WEAK:
			if (Hallucination)
			    pline((!incr) ?
				  "You still have the munchies." :
      "The munchies are interfering with your motor capabilities.");
			else if (incr &&
				(Role_if(PM_WIZARD) || Race_if(PM_ELF) ||
				 Role_if(PM_VALKYRIE)))
			    pline("%s needs food, badly!",
				  (Role_if(PM_WIZARD) || Role_if(PM_VALKYRIE)) ?
				  urole.name.m : "Elf");
			else
			    You((!incr) ? "feel weak now." :
				  (u.uhunger < 45) ? "feel weak." :
				   "are beginning to feel weak.");
			if (incr && occupation &&
			    (occupation != eatfood && occupation != opentin))
			    stop_occupation();
			context.travel = context.travel1 = context.mv = context.run = 0;
			break;
		}
		u.uhs = newhs;
		context.botl = 1;
		bot();
		if ((Upolyd ? u.mh : u.uhp) < 1) {
			You("die from hunger and exhaustion.");
			killer.format = KILLED_BY;
			Strcpy(killer.name, "exhaustion");
			done(STARVING);
			return;
		}
	}
}

/* Returns an object representing food.  Object may be either on floor or
 * in inventory.
 */
struct obj *
floorfood(verb,corpsecheck)	/* get food from floor or pack */
	const char *verb;
	int corpsecheck; /* 0, no check, 1, corpses, 2, tinnable corpses */
{
	register struct obj *otmp;
	char qbuf[QBUFSZ];
	char c;
	boolean feeding = !strcmp(verb, "eat"),		/* corpsecheck==0 */
		offering = !strcmp(verb, "sacrifice");	/* corpsecheck==1 */

	/* if we can't touch floor objects then use invent food only */
	if (!can_reach_floor(TRUE) ||
		(feeding && u.usteed) || /* can't eat off floor while riding */
		(is_pool_or_lava(u.ux, u.uy) &&
		    (Wwalking || is_clinger(youmonst.data) ||
			(Flying && !Breathless))))
	    goto skipfloor;

	if (feeding && metallivorous(youmonst.data)) {
	    struct obj *gold;
	    struct trap *ttmp = t_at(u.ux, u.uy);

	    if (ttmp && ttmp->tseen && ttmp->ttyp == BEAR_TRAP) {
		/* If not already stuck in the trap, perhaps there should
		   be a chance to becoming trapped?  Probably not, because
		   then the trap would just get eaten on the _next_ turn... */
		Sprintf(qbuf, "There is a bear trap here (%s); eat it?",
			(u.utrap && u.utraptype == TT_BEARTRAP) ?
				"holding you" : "armed");
		if ((c = yn_function(qbuf, ynqchars, 'n')) == 'y') {
		    u.utrap = u.utraptype = 0;
		    deltrap(ttmp);
		    return mksobj(BEARTRAP, TRUE, FALSE);
		} else if (c == 'q') {
		    return (struct obj *)0;
		}
	    }

	    if (youmonst.data != &mons[PM_RUST_MONSTER] &&
		(gold = g_at(u.ux, u.uy)) != 0) {
		if (gold->quan == 1L)
		    Sprintf(qbuf, "There is 1 gold piece here; eat it?");
		else
		    Sprintf(qbuf, "There are %ld gold pieces here; eat them?",
			    gold->quan);
		if ((c = yn_function(qbuf, ynqchars, 'n')) == 'y') {
		    return gold;
		} else if (c == 'q') {
		    return (struct obj *)0;
		}
	    }
	}

	/* Is there some food (probably a heavy corpse) here on the ground? */
	for (otmp = level.objects[u.ux][u.uy]; otmp; otmp = otmp->nexthere) {
	    if (corpsecheck ?
		(otmp->otyp==CORPSE && (corpsecheck == 1 || tinnable(otmp))) :
		    feeding ? (otmp->oclass != COIN_CLASS && is_edible(otmp)) :
						otmp->oclass==FOOD_CLASS) {
		char qsfx[QBUFSZ];
		boolean one = (otmp->quan == 1L);

		/* "There is <an object> here; <verb> it?" or
		   "There are <N objects> here; <verb> one?" */
		Sprintf(qbuf, "There %s ", otense(otmp, "are"));
		Sprintf(qsfx, " here; %s %s?", verb, one ? "it" : "one");
		(void)safe_qbuf(qbuf, qbuf, qsfx,
				otmp, doname, ansimpleoname,
				one ? something : (const char *)"things");
		if ((c = yn_function(qbuf,ynqchars,'n')) == 'y')
		    return(otmp);
		else if (c == 'q')
		    return((struct obj *) 0);
	    }
	}

 skipfloor:
	/* We cannot use ALL_CLASSES since that causes getobj() to skip its
	 * "ugly checks" and we need to check for inedible items.
	 */
	otmp = getobj(feeding ? allobj : offering ? offerfodder : comestibles,
		      verb);
	if (corpsecheck && otmp && !(offering && otmp->oclass == AMULET_CLASS))
	    if (otmp->otyp != CORPSE || (corpsecheck == 2 && !tinnable(otmp))) {
		You_cant("%s that!", verb);
		return (struct obj *)0;
	    }
	return otmp;
}

/* Side effects of vomiting */
/* added nomul (MRS) - it makes sense, you're too busy being sick! */
void
vomit()		/* A good idea from David Neves */
{
	if (cantvomit(youmonst.data))
	    /* doesn't cure food poisoning; message assumes that we aren't
	       dealing with some esoteric body_part() */
	    Your("jaw gapes convulsively.");
	else
	    make_sick(0L, (char *)0, TRUE, SICK_VOMITABLE);
	nomul(-2);
	multi_reason = "vomiting";
	nomovemsg = You_can_move_again;
}

int
eaten_stat(base, obj)
register int base;
register struct obj *obj;
{
	long uneaten_amt, full_amount;

	uneaten_amt = (long)obj->oeaten;
	full_amount = (obj->otyp == CORPSE) ? (long)mons[obj->corpsenm].cnutrit
					: (long)objects[obj->otyp].oc_nutrition;
	if (uneaten_amt > full_amount) {
	    impossible(
	  "partly eaten food (%ld) more nutritious than untouched food (%ld)",
		       uneaten_amt, full_amount);
	    uneaten_amt = full_amount;
	}

	base = (int)(full_amount ? (long)base * uneaten_amt / full_amount : 0L);
	return (base < 1) ? 1 : base;
}

/* reduce obj's oeaten field, making sure it never hits or passes 0 */
void
consume_oeaten(obj, amt)
struct obj *obj;
int amt;
{
    /*
     * This is a hack to try to squelch several long standing mystery
     * food bugs.  A better solution would be to rewrite the entire
     * victual handling mechanism from scratch using a less complex
     * model.  Alternatively, this routine could call done_eating()
     * or food_disappears() but its callers would need revisions to
     * cope with context.victual.piece unexpectedly going away.
     *
     * Multi-turn eating operates by setting the food's oeaten field
     * to its full nutritional value and then running a counter which
     * independently keeps track of whether there is any food left.
     * The oeaten field can reach exactly zero on the last turn, and
     * the object isn't removed from inventory until the next turn
     * when the "you finish eating" message gets delivered, so the
     * food would be restored to the status of untouched during that
     * interval.  This resulted in unexpected encumbrance messages
     * at the end of a meal (if near enough to a threshold) and would
     * yield full food if there was an interruption on the critical
     * turn.  Also, there have been reports over the years of food
     * becoming massively heavy or producing unlimited satiation;
     * this would occur if reducing oeaten via subtraction attempted
     * to drop it below 0 since its unsigned type would produce a
     * huge positive value instead.  So far, no one has figured out
     * _why_ that inappropriate subtraction might sometimes happen.
     */

    if (amt > 0) {
	/* bit shift to divide the remaining amount of food */
	obj->oeaten >>= amt;
    } else {
	/* simple decrement; value is negative so we actually add it */
	if ((int) obj->oeaten > -amt)
	    obj->oeaten += amt;
	else
	    obj->oeaten = 0;
    }

    if (obj->oeaten == 0) {
	if (obj == context.victual.piece)	/* always true unless wishing... */
	    context.victual.reqtime = context.victual.usedtime;	/* no bites left */
	obj->oeaten = 1;	/* smallest possible positive value */
    }
}

/* called when eatfood occupation has been interrupted,
   or in the case of theft, is about to be interrupted */
boolean
maybe_finished_meal(stopping)
boolean stopping;
{
	/* in case consume_oeaten() has decided that the food is all gone */
	if (occupation == eatfood && context.victual.usedtime >= context.victual.reqtime) {
	    if (stopping) occupation = 0;	/* for do_reset_eat */
	    (void) eatfood(); /* calls done_eating() to use up context.victual.piece */
	    return TRUE;
	}
	return FALSE;
}

/* Tin of <something> to the rescue?  Decide whether current occupation
   is an attempt to eat a tin of something capable of saving hero's life.
   We don't care about consumption of non-tinned food here because special
   effects there take place on first bite rather than at end of occupation.
   [Popeye the Sailor gets out of trouble by eating tins of spinach. :-] */
boolean
Popeye(threat)
int threat;
{
    struct obj *otin; 
    int mndx;

    if (occupation != opentin) return FALSE;
    otin = context.tin.tin;
    /* make sure hero still has access to tin */
    if (!carried(otin) &&
	    (!obj_here(otin, u.ux, u.uy) || !can_reach_floor(TRUE)))
	return FALSE;
    /* unknown tin is assumed to be helpful */
    if (!otin->known) return TRUE;
    /* known tin is helpful if it will stop life-threatening problem */
    mndx = otin->corpsenm;
    switch (threat) {
    /* note: not used; hunger code bypasses stop_occupation() when eating */
    case HUNGER:
	return (mndx != NON_PM || otin->spe == 1);
    /* flesh from lizards and acidic critters stops petrification */
    case STONED:
	return (mndx >= LOW_PM && (mndx == PM_LIZARD || acidic(&mons[mndx])));
    /* no tins can cure these (yet?) */
    case SLIMED:
    case SICK:
    case VOMITING:
	break;
    default:
	break;
    }
    return FALSE;
}

/*eat.c*/