Fandom

Wikihack

Source:NetHack 3.1.0/eat.c

2,034pages on
this wiki
Add New Page
Talk0

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.

Below is the full text to eat.c from the source code of NetHack 3.1.0. To link to a particular line, write [[NetHack 3.1.0/eat.c#line123]], for example.

Warning! This is the source code from an old release. For the latest release, see Source code

The NetHack General Public License applies to screenshots, source code and other content from NetHack.
1.    /*	SCCS Id: @(#)eat.c	3.1	92/12/06	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
5.    #include	"hack.h"
6.    /*#define DEBUG		/* uncomment to enable new eat code debugging */
7.    
8.    #ifdef DEBUG
9.    # ifdef WIZARD
10.   #define debugpline	if (wizard) pline
11.   # else
12.   #define debugpline	pline
13.   # endif
14.   #endif
15.   
16.   STATIC_PTR int NDECL(eatmdone);
17.   STATIC_PTR int NDECL(eatfood);
18.   STATIC_PTR int NDECL(opentin);
19.   STATIC_PTR int NDECL(unfaint);
20.   
21.   #ifdef OVLB
22.   static void FDECL(choke, (struct obj *));
23.   static void NDECL(recalc_wt);
24.   static struct obj *FDECL(touchfood, (struct obj *));
25.   static void NDECL(do_reset_eat);
26.   static void FDECL(done_eating, (BOOLEAN_P));
27.   static void FDECL(cprefx, (int));
28.   static int FDECL(intrinsic_possible, (int,struct permonst *));
29.   static void FDECL(givit, (int,struct permonst *));
30.   static void FDECL(cpostfx, (int));
31.   static void FDECL(start_tin, (struct obj *));
32.   static int FDECL(eatcorpse, (struct obj *));
33.   static void FDECL(start_eating, (struct obj *));
34.   static void FDECL(fprefx, (struct obj *));
35.   static void FDECL(fpostfx, (struct obj *));
36.   static int NDECL(bite);
37.   
38.   #ifdef POLYSELF
39.   static int FDECL(rottenfood, (struct obj *));
40.   static void NDECL(eatspecial);
41.   static void FDECL(eatring, (struct obj *));
42.   static const char * FDECL(foodword, (struct obj *));
43.   #else
44.   static int NDECL(rottenfood);
45.   #endif /* POLYSELF */
46.   
47.   char corpsename[60];
48.   char msgbuf[BUFSZ];
49.   
50.   #endif /* OVLB */
51.   
52.   /* hunger texts used on bottom line (each 8 chars long) */
53.   #define SATIATED	0
54.   #define NOT_HUNGRY	1
55.   #define HUNGRY		2
56.   #define WEAK		3
57.   #define FAINTING	4
58.   #define FAINTED		5
59.   #define STARVED		6
60.   
61.   #ifdef OVLB
62.   
63.   const char *hu_stat[] = {
64.   	"Satiated",
65.   	"        ",
66.   	"Hungry  ",
67.   	"Weak    ",
68.   	"Fainting",
69.   	"Fainted ",
70.   	"Starved "
71.   };
72.   
73.   #endif /* OVLB */
74.   
75.   #ifndef OVLB
76.   
77.   STATIC_DCL const char NEARDATA comestibles[];
78.   #ifdef POLYSELF
79.   STATIC_OVL const char NEARDATA allobj[];
80.   #endif /* POLYSELF */
81.   
82.   #else
83.   
84.   STATIC_OVL const char NEARDATA comestibles[] = { FOOD_CLASS, 0 };
85.   
86.   #ifdef POLYSELF
87.   /* Gold must come first for getobj(). */
88.   STATIC_OVL const char NEARDATA allobj[] = {
89.   	GOLD_CLASS, WEAPON_CLASS, ARMOR_CLASS, POTION_CLASS, SCROLL_CLASS,
90.   	WAND_CLASS, RING_CLASS, AMULET_CLASS, FOOD_CLASS, TOOL_CLASS,
91.   	GEM_CLASS, ROCK_CLASS, BALL_CLASS, CHAIN_CLASS, SPBOOK_CLASS, 0 };
92.   #endif /* POLYSELF */
93.   
94.   #endif /* OVLB */
95.   #ifdef OVL1
96.   # ifdef POLYSELF
97.   
98.   boolean
99.   is_edible(obj)
100.  register struct obj *obj;
101.  {
102.  	if (metallivorous(uasmon) && is_metallic(obj))
103.  		return TRUE;
104.  	if (u.umonnum == PM_GELATINOUS_CUBE && is_organic(obj))
105.  		return TRUE;
106.  	return !!index(comestibles, obj->oclass);
107.  }
108.  # endif /* POLYSELF */
109.  #endif /* OVL1 */
110.  #ifdef OVLB
111.  
112.  void
113.  init_uhunger(){
114.  	u.uhunger = 900;
115.  	u.uhs = NOT_HUNGRY;
116.  }
117.  
118.  static const struct { const char *txt; int nut; } tintxts[] = {
119.  	{"deep fried",	 60},
120.  	{"pickled",	 40},
121.  	{"soup made from", 20},
122.  	{"pureed",	500},
123.  	{"rotten",	-50},
124.  	{"homemade",	 50},
125.  	{"", 0}
126.  };
127.  #define	TTSZ	SIZE(tintxts)
128.  
129.  static struct {
130.  	struct	obj *tin;
131.  	int	usedtime, reqtime;
132.  } NEARDATA tin;
133.  
134.  static struct {
135.  	struct	obj *piece;	/* the thing being eaten, or last thing that
136.  				 * was partially eaten, unless that thing was
137.  				 * a tin, which uses the tin structure above */
138.  	int	usedtime,	/* turns spent eating */
139.  		reqtime;	/* turns required to eat */
140.  	int	nmod;		/* coded nutrition per turn */
141.  	Bitfield(canchoke,1);	/* was satiated at beginning */
142.  	Bitfield(fullwarn,1);	/* have warned about being full */
143.  	Bitfield(eating,1);	/* victual currently being eaten */
144.  	Bitfield(doreset,1);	/* stop eating at end of turn */
145.  } NEARDATA victual;
146.  
147.  STATIC_PTR
148.  int
149.  eatmdone() {		/* called after mimicing is over */
150.  	u.usym =
151.  #ifdef POLYSELF
152.  		u.mtimedone ? uasmon->mlet :
153.  #endif
154.  		S_HUMAN;
155.  	newsym(u.ux,u.uy);
156.  	return 0;
157.  }
158.  
159.  /* Created by GAN 01/28/87
160.   * Amended by AKP 09/22/87: if not hard, don't choke, just vomit.
161.   * Amended by 3.  06/12/89: if not hard, sometimes choke anyway, to keep risk.
162.   *		  11/10/89: if hard, rarely vomit anyway, for slim chance.
163.   */
164.  /*ARGSUSED*/
165.  static void
166.  choke(food)	/* To a full belly all food is bad. (It.) */
167.  	register struct obj *food;
168.  {
169.  	/* only happens if you were satiated */
170.  	if(u.uhs != SATIATED) return;
171.  
172.  	if (pl_character[0] == 'K' && u.ualign.type == A_LAWFUL)
173.  		u.ualign.record--;	/* gluttony is unchivalrous */
174.  
175.  	if (!rn2(20)) {
176.  		You("stuff yourself and then vomit voluminously.");
177.  		morehungry(1000);	/* you just got *very* sick! */
178.  		vomit();
179.  	} else {
180.  		killer_format = KILLED_BY_AN;
181.  		/*
182.  		 * Note all "killer"s below read "Choked on %s" on the
183.  		 * high score list & tombstone.  So plan accordingly.
184.  		 */
185.  		if(food) {
186.  #ifdef POLYSELF
187.  			You("choke over your %s.", foodword(food));
188.  			if (food->oclass == GOLD_CLASS) {
189.  				killer_format = KILLED_BY;
190.  				killer = "eating too rich a meal";
191.  			} else {
192.  #else
193.  				You("choke over your food.");
194.  #endif
195.  				killer = singular(food, xname);
196.  #ifdef POLYSELF
197.  			}
198.  #endif
199.  		} else {
200.  			You("choke over it.");
201.  			killer = "quick snack";
202.  		}
203.  		You("die...");
204.  		done(CHOKING);
205.  	}
206.  }
207.  
208.  static void
209.  recalc_wt() {	/* modify object wt. depending on time spent consuming it */
210.  	register struct obj *piece = victual.piece;
211.  
212.  #ifdef DEBUG
213.  	debugpline("Old weight = %d", piece->owt);
214.  	debugpline("Used time = %d, Req'd time = %d",
215.  		victual.usedtime, victual.reqtime);
216.  #endif
217.  	/* weight(piece) = weight of full item */
218.  	if(victual.usedtime)
219.  	    piece->owt = eaten_stat(weight(piece), piece);
220.  #ifdef DEBUG
221.  	debugpline("New weight = %d", piece->owt);
222.  #endif
223.  }
224.  
225.  void
226.  reset_eat() {		/* called when eating interrupted by an event */
227.  
228.      /* we only set a flag here - the actual reset process is done after
229.       * the round is spent eating.
230.       */
231.  	if(victual.eating && !victual.doreset) {
232.  #ifdef DEBUG
233.  	    debugpline("reset_eat...");
234.  #endif
235.  	    victual.doreset = TRUE;
236.  	}
237.  	return;
238.  }
239.  
240.  void
241.  bill_dummy_object(otmp)
242.  register struct obj *otmp;
243.  {
244.  	/* Create a dummy duplicate to put on bill.  The duplicate exists
245.  	 * only in the billobjs chain.  This function is used when a store
246.  	 * object is being altered, and a copy of the original is needed
247.  	 * for billing purposes.
248.  	 */
249.  	register struct obj *dummy;
250.  
251.  	if(otmp->unpaid)
252.  		subfrombill(otmp, shop_keeper(*u.ushops));
253.  	dummy = newobj(otmp->onamelth);
254.  	*dummy = *otmp;
255.  	dummy->o_id = flags.ident++;
256.  	dummy->owt = weight(dummy);
257.  	if(otmp->onamelth)
258.  		(void)strncpy(ONAME(dummy),ONAME(otmp), (int)otmp->onamelth);
259.  	if(Is_candle(dummy)) dummy->lamplit = 0;
260.  	addtobill(dummy, FALSE, TRUE, TRUE);
261.  }
262.  
263.  static struct obj *
264.  touchfood(otmp)
265.  register struct obj *otmp;
266.  {
267.  	if (otmp->quan > 1L) {
268.  	    if(!carried(otmp))
269.  		(void) splitobj(otmp, 1L);
270.  	    else
271.  		otmp = splitobj(otmp, otmp->quan - 1L);
272.  #ifdef DEBUG
273.  	    debugpline("split object,");
274.  #endif
275.  	}
276.  
277.  	if (!otmp->oeaten) {
278.  	    if(((!carried(otmp) && costly_spot(otmp->ox, otmp->oy) &&
279.  		 saleable(rooms[*u.ushops-ROOMOFFSET].rtype-SHOPBASE, otmp))
280.  		 || otmp->unpaid) &&
281.  		 (otmp->otyp == CORPSE || objects[otmp->otyp].oc_delay > 1)) {
282.  		/* create a dummy duplicate to put on bill */
283.  		You("bite it, you bought it!");
284.  		bill_dummy_object(otmp);
285.  	    }
286.  	    otmp->oeaten = (otmp->otyp == CORPSE ?
287.  				(int)mons[otmp->corpsenm].cnutrit :
288.  				objects[otmp->otyp].oc_nutrition);
289.  	}
290.  
291.  	if (carried(otmp)) {
292.  	    freeinv(otmp);
293.  	    if(inv_cnt() >= 52)
294.  		dropy(otmp);
295.  	    else
296.  		otmp = addinv(otmp); /* unlikely but a merge is possible */
297.  	}
298.  	return(otmp);
299.  }
300.  
301.  /* When food decays, in the middle of your meal, we don't want to dereference
302.   * any dangling pointers, so set it to null (which should still trigger
303.   * do_reset_eat() at the beginning of eatfood()) and check for null pointers
304.   * in do_reset_eat().
305.   */
306.  void
307.  food_disappears(obj)
308.  register struct obj *obj;
309.  {
310.  	if (obj == victual.piece) victual.piece = (struct obj *)0;
311.  }
312.  
313.  static void
314.  do_reset_eat() {
315.  
316.  #ifdef DEBUG
317.  	debugpline("do_reset_eat...");
318.  #endif
319.  	if (victual.piece) {
320.  		victual.piece = touchfood(victual.piece);
321.  		recalc_wt();
322.  	}
323.  	victual.fullwarn = victual.eating = victual.doreset = FALSE;
324.  	/* Do not set canchoke to FALSE; if we continue eating the same object
325.  	 * we need to know if canchoke was set when they started eating it the
326.  	 * previous time.  And if we don't continue eating the same object
327.  	 * canchoke always gets recalculated anyway.
328.  	 */
329.  	stop_occupation();
330.  }
331.  
332.  STATIC_PTR
333.  int
334.  eatfood() {		/* called each move during eating process */
335.  	if(!carried(victual.piece) && !obj_here(victual.piece, u.ux, u.uy)) {
336.  		/* maybe it was stolen? */
337.  		do_reset_eat();
338.  		return(0);
339.  	}
340.  	if(!victual.eating) return(0);
341.  
342.  	if(++victual.usedtime < victual.reqtime) {
343.  	    if(bite()) return(0);
344.  	    return(1);	/* still busy */
345.  	} else {	/* done */
346.  	    done_eating(TRUE);
347.  	    return(0);
348.  	}
349.  }
350.  
351.  static void
352.  done_eating(message)
353.  boolean message;
354.  {
355.  #ifndef NO_SIGNAL
356.  	victual.piece->in_use = TRUE;
357.  #endif
358.  	if (nomovemsg) {
359.  		if (message) pline(nomovemsg);
360.  		nomovemsg = 0;
361.  	} else if (message)
362.  		You("finish eating %s.", the(singular(victual.piece, xname)));
363.  
364.  	if(victual.piece->otyp == CORPSE)
365.  		cpostfx(victual.piece->corpsenm);
366.  	else
367.  		fpostfx(victual.piece);
368.  
369.  	if (carried(victual.piece)) useup(victual.piece);
370.  	else useupf(victual.piece);
371.  	victual.piece = (struct obj *) 0;
372.  	victual.fullwarn = victual.eating = victual.doreset = FALSE;
373.  }
374.  
375.  static void
376.  cprefx(pm)
377.  register int pm;
378.  {
379.  	if ((pl_character[0]=='E') ? is_elf(&mons[pm]) : is_human(&mons[pm])) {
380.  		You("cannibal!  You will regret this!");
381.  		Aggravate_monster |= FROMOUTSIDE;
382.  	}
383.  
384.  	switch(pm) {
385.  	    case PM_LITTLE_DOG:
386.  	    case PM_DOG:
387.  	    case PM_LARGE_DOG:
388.  	    case PM_KITTEN:
389.  	    case PM_HOUSECAT:
390.  	    case PM_LARGE_CAT:
391.  		You("feel that eating the %s was a bad idea.", mons[pm].mname);
392.  		Aggravate_monster |= FROMOUTSIDE;
393.  		break;
394.  	    case PM_COCKATRICE:
395.  	    case PM_MEDUSA:
396.  #ifdef POLYSELF
397.  		if(!resists_ston(uasmon))
398.  		    if(!(poly_when_stoned(uasmon) && polymon(PM_STONE_GOLEM)))
399.  #endif
400.  			{
401.  			char *cruft;	/* killer is const char * */
402.  			killer_format = KILLED_BY;
403.  			killer = cruft = (char *)  /* sizeof "s" includes \0 */
404.  					alloc((unsigned) strlen(mons[pm].mname)
405.  						+ sizeof " meat");
406.  			Sprintf(cruft, "%s meat", mons[pm].mname);
407.  			You("turn to stone.");
408.  			done(STONING);
409.  			}
410.  			break;
411.  	    case PM_LIZARD:
412.  		/* Relief from cockatrices -dgk */
413.  		if (Stoned) {
414.  			Stoned = 0;
415.  			You("feel limber!");
416.  		}
417.  		break;
418.  	    case PM_DEATH:
419.  	    case PM_PESTILENCE:
420.  	    case PM_FAMINE:
421.  		{ char buf[BUFSZ];
422.  		    pline("Eating that is instantly fatal.");
423.  		    Sprintf(buf, "unwisely ate the body of %s",
424.  			    mons[pm].mname);
425.  		    killer = buf;
426.  		    killer_format = NO_KILLER_PREFIX;
427.  		    done(DIED);
428.  		    /* It so happens that since we know these monsters */
429.  		    /* cannot appear in tins, victual.piece will always */
430.  		    /* be what we want, which is not generally true. */
431.  		    revive_corpse(victual.piece, 0, FALSE);
432.  		    return;
433.  		}
434.  	    default:
435.  		if(acidic(&mons[pm]) && Stoned) {
436.  		    pline("What a pity - you just destroyed a future piece of art!");
437.  		    Stoned = 0;
438.  		}
439.  	}
440.  	return;
441.  }
442.  
443.  
444.  /*
445.   * If you add an intrinsic that can be gotten by eating a monster, add it
446.   * to intrinsic_possible() and givit().  (It must already be in prop.h to
447.   * be an intrinsic property.)
448.   * It would be very easy to make the intrinsics not try to give you one
449.   * that you already had by checking to see if you have it in
450.   * intrinsic_possible() instead of givit().
451.   */
452.  
453.  /* intrinsic_possible() returns TRUE iff a monster can give an intrinsic. */
454.  static int
455.  intrinsic_possible(type, ptr)
456.  int type;
457.  register struct permonst *ptr;
458.  {
459.  	switch (type) {
460.  	    case FIRE_RES:
461.  #ifdef DEBUG
462.  		if (ptr->mconveys & MR_FIRE) {
463.  			debugpline("can get fire resistance");
464.  			return(TRUE);
465.  		} else  return(FALSE);
466.  #else
467.  		return(ptr->mconveys & MR_FIRE);
468.  #endif
469.  	    case SLEEP_RES:
470.  #ifdef DEBUG
471.  		if (ptr->mconveys & MR_SLEEP) {
472.  			debugpline("can get sleep resistance");
473.  			return(TRUE);
474.  		} else  return(FALSE);
475.  #else
476.  		return(ptr->mconveys & MR_SLEEP);
477.  #endif
478.  	    case COLD_RES:
479.  #ifdef DEBUG
480.  		if (ptr->mconveys & MR_COLD) {
481.  			debugpline("can get cold resistance");
482.  			return(TRUE);
483.  		} else  return(FALSE);
484.  #else
485.  		return(ptr->mconveys & MR_COLD);
486.  #endif
487.  	    case DISINT_RES:
488.  #ifdef DEBUG
489.  		if (ptr->mconveys & MR_DISINT) {
490.  			debugpline("can get disintegration resistance");
491.  			return(TRUE);
492.  		} else  return(FALSE);
493.  #else
494.  		return(ptr->mconveys & MR_DISINT);
495.  #endif
496.  	    case SHOCK_RES:	/* shock (electricity) resistance */
497.  #ifdef DEBUG
498.  		if (ptr->mconveys & MR_ELEC) {
499.  			debugpline("can get shock resistance");
500.  			return(TRUE);
501.  		} else  return(FALSE);
502.  #else
503.  		return(ptr->mconveys & MR_ELEC);
504.  #endif
505.  	    case POISON_RES:
506.  #ifdef DEBUG
507.  		if (ptr->mconveys & MR_POISON) {
508.  			debugpline("can get poison resistance");
509.  			return(TRUE);
510.  		} else  return(FALSE);
511.  #else
512.  		return(ptr->mconveys & MR_POISON);
513.  #endif
514.  	    case TELEPORT:
515.  #ifdef DEBUG
516.  		if (can_teleport(ptr)) {
517.  			debugpline("can get teleport");
518.  			return(TRUE);
519.  		} else  return(FALSE);
520.  #else
521.  		return(can_teleport(ptr));
522.  #endif
523.  	    case TELEPORT_CONTROL:
524.  #ifdef DEBUG
525.  		if (control_teleport(ptr)) {
526.  			debugpline("can get teleport control");
527.  			return(TRUE);
528.  		} else  return(FALSE);
529.  #else
530.  		return(control_teleport(ptr));
531.  #endif
532.  	    case TELEPAT:
533.  #ifdef DEBUG
534.  		if (telepathic(ptr)) {
535.  			debugpline("can get telepathy");
536.  			return(TRUE);
537.  		} else  return(FALSE);
538.  #else
539.  		return(telepathic(ptr));
540.  #endif
541.  	    default:
542.  		return(FALSE);
543.  	}
544.  	/*NOTREACHED*/
545.  }
546.  
547.  /* givit() tries to give you an intrinsic based on the monster's level
548.   * and what type of intrinsic it is trying to give you.
549.   */
550.  static void
551.  givit(type, ptr)
552.  int type;
553.  register struct permonst *ptr;
554.  {
555.  	register int chance;
556.  
557.  #ifdef DEBUG
558.  	debugpline("Attempting to give intrinsic %d", type);
559.  #endif
560.  	/* some intrinsics are easier to get than others */
561.  	switch (type) {
562.  		case POISON_RES:
563.  			if ((ptr == &mons[PM_KILLER_BEE] ||
564.  					ptr == &mons[PM_SCORPION]) && !rn2(4))
565.  				chance = 1;
566.  			else
567.  				chance = 15;
568.  			break;
569.  		case TELEPORT:
570.  			chance = 10;
571.  			break;
572.  		case TELEPORT_CONTROL:
573.  			chance = 12;
574.  			break;
575.  		case TELEPAT:
576.  			chance = 1;
577.  			break;
578.  		default:
579.  			chance = 15;
580.  			break;
581.  	}
582.  
583.  	if (ptr->mlevel <= rn2(chance))
584.  		return;		/* failed die roll */
585.  
586.  	switch (type) {
587.  	    case FIRE_RES:
588.  #ifdef DEBUG
589.  		debugpline("Trying to give fire resistance");
590.  #endif
591.  		if(!(HFire_resistance & FROMOUTSIDE)) {
592.  			You("feel a momentary chill.");
593.  			HFire_resistance |= FROMOUTSIDE;
594.  		}
595.  		break;
596.  	    case SLEEP_RES:
597.  #ifdef DEBUG
598.  		debugpline("Trying to give sleep resistance");
599.  #endif
600.  		if(!(HSleep_resistance & FROMOUTSIDE)) {
601.  			You("feel wide awake.");
602.  			HSleep_resistance |= FROMOUTSIDE;
603.  		}
604.  		break;
605.  	    case COLD_RES:
606.  #ifdef DEBUG
607.  		debugpline("Trying to give cold resistance");
608.  #endif
609.  		if(!(HCold_resistance & FROMOUTSIDE)) {
610.  			You("feel full of hot air.");
611.  			HCold_resistance |= FROMOUTSIDE;
612.  		}
613.  		break;
614.  	    case DISINT_RES:
615.  #ifdef DEBUG
616.  		debugpline("Trying to give disintegration resistance");
617.  #endif
618.  		if(!(HDisint_resistance & FROMOUTSIDE)) {
619.  			You("feel very firm.");
620.  			HDisint_resistance |= FROMOUTSIDE;
621.  		}
622.  		break;
623.  	    case SHOCK_RES:	/* shock (electricity) resistance */
624.  #ifdef DEBUG
625.  		debugpline("Trying to give shock resistance");
626.  #endif
627.  		if(!(HShock_resistance & FROMOUTSIDE)) {
628.  			Your("health currently feels amplified!");
629.  			HShock_resistance |= FROMOUTSIDE;
630.  		}
631.  		break;
632.  	    case POISON_RES:
633.  #ifdef DEBUG
634.  		debugpline("Trying to give poison resistance");
635.  #endif
636.  		if(!(HPoison_resistance & FROMOUTSIDE)) {
637.  			You("feel healthy.");
638.  			HPoison_resistance |= FROMOUTSIDE;
639.  		}
640.  		break;
641.  	    case TELEPORT:
642.  #ifdef DEBUG
643.  		debugpline("Trying to give teleport");
644.  #endif
645.  		if(!(HTeleportation & FROMOUTSIDE)) {
646.  			You("feel very jumpy.");
647.  			HTeleportation |= FROMOUTSIDE;
648.  		}
649.  		break;
650.  	    case TELEPORT_CONTROL:
651.  #ifdef DEBUG
652.  		debugpline("Trying to give teleport control");
653.  #endif
654.  		if(!(HTeleport_control & FROMOUTSIDE)) {
655.  			You("feel in control of yourself.");
656.  			HTeleport_control |= FROMOUTSIDE;
657.  		}
658.  		break;
659.  	    case TELEPAT:
660.  #ifdef DEBUG
661.  		debugpline("Trying to give telepathy");
662.  #endif
663.  		if(!(HTelepat & FROMOUTSIDE)) {
664.  			You("feel a %s mental acuity.",
665.  				Hallucination ? "normal" : "strange");
666.  			HTelepat |= FROMOUTSIDE;
667.  			/* If blind, make sure monsters show up. */
668.  			if (Blind) see_monsters();
669.  		}
670.  		break;
671.  	    default:
672.  #ifdef DEBUG
673.  		debugpline("Tried to give an impossible intrinsic");
674.  #endif
675.  		break;
676.  	}
677.  }
678.  
679.  static void
680.  cpostfx(pm)		/* called after completely consuming a corpse */
681.  register int pm;
682.  {
683.  	register int tmp = 0;
684.  
685.  	switch(pm) {
686.  	    case PM_WRAITH:
687.  		pluslvl();
688.  		break;
689.  #ifdef POLYSELF
690.  	    case PM_HUMAN_WERERAT:
691.  		u.ulycn = PM_WERERAT;
692.  		break;
693.  	    case PM_HUMAN_WEREJACKAL:
694.  		u.ulycn = PM_WEREJACKAL;
695.  		break;
696.  	    case PM_HUMAN_WEREWOLF:
697.  		u.ulycn = PM_WEREWOLF;
698.  		break;
699.  #endif
700.  	    case PM_NURSE:
701.  		u.uhp = u.uhpmax;
702.  		flags.botl = 1;
703.  		break;
704.  	    case PM_STALKER:
705.  		if(!Invis) {
706.  			HInvis = rn1(100, 50);
707.  			if(!See_invisible)
708.  				newsym(u.ux, u.uy);
709.  		} else {
710.  			register long oldprop = See_invisible;
711.  			if (!(HInvis & INTRINSIC)) You("feel hidden!");
712.  			HInvis |= FROMOUTSIDE;
713.  			HSee_invisible |= FROMOUTSIDE;
714.  			if (!oldprop)
715.  				newsym(u.ux, u.uy);
716.  		}
717.  		/* fall into next case */
718.  	    case PM_YELLOW_LIGHT:
719.  		/* fall into next case */
720.  	    case PM_GIANT_BAT:
721.  		make_stunned(HStun + 30,FALSE);
722.  		/* fall into next case */
723.  	    case PM_BAT:
724.  		make_stunned(HStun + 30,FALSE);
725.  		break;
726.  	    case PM_GIANT_MIMIC:
727.  		tmp += 10;
728.  		/* fall into next case */
729.  	    case PM_LARGE_MIMIC:
730.  		tmp += 20;
731.  		/* fall into next case */
732.  	    case PM_SMALL_MIMIC:
733.  		tmp += 20;
734.  		if(u.usym == S_HUMAN) {
735.  		    You("cannot resist the temptation to mimic a pile of gold.");
736.  		    nomul(-tmp);
737.  		    afternmv = eatmdone;
738.  		    if (pl_character[0]=='E')
739.  			nomovemsg = "You now again prefer mimicking an elf.";
740.  		    else
741.  			nomovemsg = "You now again prefer mimicking a human.";
742.  		    u.usym = 0; /* hack! no monster sym 0; use for gold */
743.  		    newsym(u.ux,u.uy);
744.  		}
745.  		break;
746.  	    case PM_QUANTUM_MECHANIC:
747.  		Your("velocity suddenly seems very uncertain!");
748.  		if (Fast & INTRINSIC) {
749.  			Fast &= ~INTRINSIC;
750.  			You("seem slower.");
751.  		} else {
752.  			Fast |= FROMOUTSIDE;
753.  			You("seem faster.");
754.  		}
755.  		break;
756.  	    case PM_LIZARD:
757.  		if (HStun > 2)  make_stunned(2L,FALSE);
758.  		if (HConfusion > 2)  make_confused(2L,FALSE);
759.  		break;
760.  	    case PM_CHAMELEON:
761.  		You("feel a change coming over you.");
762.  #ifdef POLYSELF
763.  		polyself();
764.  #else
765.  		newman();
766.  #endif
767.  		break;
768.  	    case PM_MIND_FLAYER:
769.  		if (ABASE(A_INT) < ATTRMAX(A_INT)) {
770.  			if (!rn2(2)) {
771.  				pline("Yum! That was real brain food!");
772.  				(void) adjattrib(A_INT, 1, FALSE);
773.  				break;	/* don't give them telepathy, too */
774.  			}
775.  		}
776.  		else {
777.  			pline("For some reason, that tasted bland.");
778.  		}
779.  		/* fall through to default case */
780.  	    default: {
781.  		register struct permonst *ptr = &mons[pm];
782.  		int i, count;
783.  
784.  		if(dmgtype(ptr, AD_STUN) || pm==PM_VIOLET_FUNGUS) {
785.  			pline ("Oh wow!  Great stuff!");
786.  			make_hallucinated(HHallucination + 200,FALSE,0L);
787.  		}
788.  		/* prevent polymorph abuse by killing/eating your offspring */
789.  		if(pm >= PM_BABY_GRAY_DRAGON && pm <= PM_BABY_YELLOW_DRAGON)
790.  			return;
791.  		if(is_giant(ptr)) gainstr((struct obj *)0, 0);
792.  
793.  		/* Check the monster for all of the intrinsics.  If this
794.  		 * monster can give more than one, pick one to try to give
795.  		 * from among all it can give.
796.  		 *
797.  		 * If a monster can give 4 intrinsics then you have
798.  		 * a 1/1 * 1/2 * 2/3 * 3/4 = 1/4 chance of getting the first,
799.  		 * a 1/2 * 2/3 * 3/4 = 1/4 chance of getting the second,
800.  		 * a 1/3 * 3/4 = 1/4 chance of getting the third,
801.  		 * and a 1/4 chance of getting the fourth.
802.  		 *
803.  		 * And now a proof by induction:
804.  		 * it works for 1 intrinsic (1 in 1 of getting it)
805.  		 * for 2 you have a 1 in 2 chance of getting the second,
806.  		 *	otherwise you keep the first
807.  		 * for 3 you have a 1 in 3 chance of getting the third,
808.  		 *	otherwise you keep the first or the second
809.  		 * for n+1 you have a 1 in n+1 chance of getting the (n+1)st,
810.  		 *	otherwise you keep the previous one.
811.  		 * Elliott Kleinrock, October 5, 1990
812.  		 */
813.  
814.  		 count = 0;	/* number of possible intrinsics */
815.  		 tmp = 0;	/* which one we will try to give */
816.  		 for (i = 1; i <= LAST_PROP; i++) {
817.  			if (intrinsic_possible(i, ptr)) {
818.  				count++;
819.  				/* a 1 in count chance of replacing the old
820.  				 * one with this one, and a count-1 in count
821.  				 * chance of keeping the old one.  (note
822.  				 * that 1 in 1 and 0 in 1 are what we want
823.  				 * for the first one
824.  				 */
825.  				if (!rn2(count)) {
826.  #ifdef DEBUG
827.  					debugpline("Intrinsic %d replacing %d",
828.  								i, tmp);
829.  #endif
830.  					tmp = i;
831.  				}
832.  			}
833.  		 }
834.  
835.  		 /* if any found try to give them one */
836.  		 if (count) givit(tmp, ptr);
837.  	    }
838.  	    break;
839.  	}
840.  	return;
841.  }
842.  
843.  STATIC_PTR
844.  int
845.  opentin()		/* called during each move whilst opening a tin */
846.  {
847.  	register int r;
848.  
849.  	if(!carried(tin.tin) && !obj_here(tin.tin, u.ux, u.uy))
850.  					/* perhaps it was stolen? */
851.  		return(0);		/* %% probably we should use tinoid */
852.  	if(tin.usedtime++ >= 50) {
853.  		You("give up your attempt to open the tin.");
854.  		return(0);
855.  	}
856.  	if(tin.usedtime < tin.reqtime)
857.  		return(1);		/* still busy */
858.  	if(tin.tin->cursed && tin.tin->spe != -1 && !rn2(8)) {
859.  		b_trapped("tin");
860.  		goto use_me;
861.  	}
862.  	You("succeed in opening the tin.");
863.  	if(tin.tin->spe != 1) {
864.  	    if(tin.tin->corpsenm == -1) {
865.  		pline("It turns out to be empty.");
866.  		tin.tin->dknown = tin.tin->known = TRUE;
867.  		goto use_me;
868.  	    }
869.  	    r = tin.tin->cursed ? 4 :		/* Always rotten if cursed */
870.  		    (tin.tin->spe == -1) ? 5 :	/* "homemade" if player made */
871.  			rn2(TTSZ-1);		/* else take your pick */
872.  	    pline("It smells like %s.", makeplural(
873.  		  Hallucination ? rndmonnam() : mons[tin.tin->corpsenm].mname));
874.  	    if (yn("Eat it?") == 'n') {
875.  		if (!Hallucination) tin.tin->dknown = tin.tin->known = TRUE;
876.  		if (flags.verbose) You("discard the open tin.");
877.  		goto use_me;
878.  	    }
879.  	    You("consume %s %s.", tintxts[r].txt,
880.  			mons[tin.tin->corpsenm].mname);
881.  	    tin.tin->dknown = tin.tin->known = TRUE;
882.  	    cprefx(tin.tin->corpsenm); cpostfx(tin.tin->corpsenm);
883.  
884.  	    /* check for vomiting added by GAN 01/16/87 */
885.  	    if(tintxts[r].nut < 0) make_vomiting((long)rn1(15,10), FALSE);
886.  	    else lesshungry(tintxts[r].nut);
887.  
888.  	    if(r == 0) {			/* Deep Fried */
889.  		Glib = rnd(15);
890.  		pline("Eating deep fried food made your %s very slippery.",
891.  			makeplural(body_part(FINGER)));
892.  	    }
893.  	} else {
894.  	    if (tin.tin->cursed)
895.  		pline("It contains some decaying %s substance.",
896.  			Hallucination ? hcolor() : green);
897.  	    else
898.  		pline("It contains spinach.");
899.  
900.  	    if (yn("Eat it?") == 'n') {
901.  		if (!Hallucination && !tin.tin->cursed)
902.  		    tin.tin->dknown = tin.tin->known = TRUE;
903.  		if (flags.verbose)
904.  		    You("discard the open tin.");
905.  		goto use_me;
906.  	    }
907.  	    if (!tin.tin->cursed)
908.  		pline("This makes you feel like %s!",
909.  		      Hallucination ? "Swee'pea" : "Popeye");
910.  	    lesshungry(600);
911.  	    gainstr(tin.tin, 0);
912.  	}
913.  	tin.tin->dknown = tin.tin->known = TRUE;
914.  use_me:
915.  	if (carried(tin.tin)) useup(tin.tin);
916.  	else useupf(tin.tin);
917.  	tin.tin = (struct obj *) 0;
918.  	return(0);
919.  }
920.  
921.  static void
922.  start_tin(otmp)		/* called when starting to open a tin */
923.  	register struct obj *otmp;
924.  {
925.  	register int tmp;
926.  
927.  #ifdef POLYSELF
928.  	if (metallivorous(uasmon)) {
929.  		You("bite right into the metal tin....");
930.  		tmp = 1;
931.  	} else
932.  #endif
933.  	if (otmp->blessed) {
934.  		pline("The tin opens like magic!");
935.  		tmp = 1;
936.  	} else if(uwep) {
937.  		switch(uwep->otyp) {
938.  		case TIN_OPENER:
939.  			tmp = 1;
940.  			break;
941.  		case DAGGER:
942.  		case ELVEN_DAGGER:
943.  		case ORCISH_DAGGER:
944.  		case ATHAME:
945.  		case CRYSKNIFE:
946.  			tmp = 3;
947.  			break;
948.  		case PICK_AXE:
949.  		case AXE:
950.  			tmp = 6;
951.  			break;
952.  		default:
953.  			goto no_opener;
954.  		}
955.  		pline("Using your %s you try to open the tin.",
956.  			aobjnam(uwep, NULL));
957.  	} else {
958.  no_opener:
959.  		pline("It is not so easy to open this tin.");
960.  		if(Glib) {
961.  			pline("The tin slips out of your hands.");
962.  			if(otmp->quan > 1L) {
963.  				register struct obj *obj;
964.  				obj = splitobj(otmp, 1L);
965.  				if(otmp == uwep) setuwep(obj);
966.  			}
967.  			if (carried(otmp)) dropx(otmp);
968.  			else stackobj(otmp);
969.  			return;
970.  		}
971.  		tmp = rn1(1 + 500/((int)(ACURR(A_DEX) + ACURRSTR)), 10);
972.  	}
973.  	tin.reqtime = tmp;
974.  	tin.usedtime = 0;
975.  	tin.tin = otmp;
976.  	set_occupation(opentin, "opening the tin", 0);
977.  	return;
978.  }
979.  
980.  int
981.  Hear_again() {		/* called when waking up after fainting */
982.  	flags.soundok = 1;
983.  	return 0;
984.  }
985.  
986.  static int
987.  #ifdef POLYSELF
988.  rottenfood(obj)
989.  struct obj *obj;
990.  #else
991.  rottenfood()
992.  #endif
993.  {		/* called on the "first bite" of rotten food */
994.  #ifdef POLYSELF
995.  	pline("Blecch!  Rotten %s!", foodword(obj));
996.  #else
997.  	pline("Blecch!  Rotten food!");
998.  #endif
999.  	if(!rn2(4)) {
1000. 		if (Hallucination) You("feel rather trippy.");
1001. 		else You("feel rather %s.", body_part(LIGHT_HEADED));
1002. 		make_confused(HConfusion + d(2,4),FALSE);
1003. 	} else if(!rn2(4) && !Blind) {
1004. 		pline("Everything suddenly goes dark.");
1005. 		make_blinded((long)d(2,10),FALSE);
1006. 	} else if(!rn2(3)) {
1007. 		if(Blind)
1008. 		  pline("The world spins and you slap against the floor.");
1009. 		else
1010. 		  pline("The world spins and goes dark.");
1011. 		flags.soundok = 0;
1012. 		nomul(-rnd(10));
1013. 		nomovemsg = "You are conscious again.";
1014. 		afternmv = Hear_again;
1015. 		return(1);
1016. 	}
1017. 	return(0);
1018. }
1019. 
1020. static int
1021. eatcorpse(otmp)		/* called when a corpse is selected as food */
1022. 	register struct obj *otmp;
1023. {
1024. 	register const char *cname = mons[otmp->corpsenm].mname;
1025. 	register int tp, rotted = 0;
1026. 
1027. 	tp = 0;
1028. 
1029. 	if(otmp->corpsenm != PM_LIZARD) {
1030. #ifndef LINT	/* problem if more than 320K moves before try to eat */
1031. 		rotted = (monstermoves - otmp->age)/((long)(10 + rn2(20)));
1032. #endif
1033. 
1034. 		if(otmp->cursed) rotted += 2;
1035. 		else if (otmp->blessed) rotted -= 2;
1036. 	}
1037. 
1038. 	if(otmp->corpsenm != PM_ACID_BLOB && (rotted > 5)) {
1039. 		pline("Ulch - that %s was tainted!",
1040. 		      mons[otmp->corpsenm].mlet == S_FUNGUS ? "fungoid vegetation" :
1041. 		      is_meaty(&mons[otmp->corpsenm]) ? "meat" : "protoplasm");
1042. #ifdef POLYSELF
1043. 		if (u.usym == S_FUNGUS)
1044. 			pline("It doesn't seem at all sickening, though...");
1045. 		else {
1046. #endif
1047. 			make_sick((long) rn1(10, 10),FALSE);
1048. 			Sprintf(corpsename, "rotted %s corpse", cname);
1049. 			u.usick_cause = (const char *)corpsename;
1050. 			flags.botl = 1;
1051. #ifdef POLYSELF
1052. 		}
1053. #endif
1054. 		if (carried(otmp)) useup(otmp);
1055. 		else useupf(otmp);
1056. 		return(1);
1057. 	} else if(acidic(&mons[otmp->corpsenm])
1058. #ifdef POLYSELF
1059. 		  && !resists_acid(uasmon)
1060. #endif
1061. 		 ) {
1062. 		tp++;
1063. 		You("have a very bad case of stomach acid.");
1064. 		losehp(rnd(15), "acidic corpse", KILLED_BY_AN);
1065. 	} else if(poisonous(&mons[otmp->corpsenm]) && rn2(5)) {
1066. 		tp++;
1067. 		pline("Ecch - that must have been poisonous!");
1068. 		if(!Poison_resistance) {
1069. 			losestr(rnd(4));
1070. 			losehp(rnd(15), "poisonous corpse", KILLED_BY_AN);
1071. 		} else	You("seem unaffected by the poison.");
1072. 	/* now any corpse left too long will make you mildly ill */
1073. 	} else if(((rotted > 5) || ((rotted > 3) && rn2(5)))
1074. #ifdef POLYSELF
1075. 		&& u.usym != S_FUNGUS
1076. #endif
1077. 							){
1078. 		tp++;
1079. 		You("feel%s sick.", (Sick) ? " very" : "");
1080. 		losehp(rnd(8), "cadaver", KILLED_BY_AN);
1081. 	}
1082. 	if(!tp && otmp->corpsenm != PM_LIZARD && (otmp->orotten || !rn2(7))) {
1083. #ifdef POLYSELF
1084. 	    if(rottenfood(otmp)) {
1085. #else
1086. 	    if(rottenfood()) {
1087. #endif
1088. 		otmp->orotten = TRUE;
1089. 		(void)touchfood(otmp);
1090. 		return(1);
1091. 	    }
1092. 	    otmp->oeaten >>= 2;
1093. 	} else {
1094. #ifdef POLYSELF
1095. 	    pline("This %s corpse %s!", cname,
1096. 		(carnivorous(uasmon) && !herbivorous(uasmon))
1097. 		? "is delicious" : "tastes terrible");
1098. #else
1099. 	    pline("This %s corpse tastes terrible!", cname);
1100. #endif
1101. 	}
1102. 
1103. 	/* delay is weight dependent */
1104. 	victual.reqtime = 3 + (mons[otmp->corpsenm].cwt >> 6);
1105. 	return(0);
1106. }
1107. 
1108. static void
1109. start_eating(otmp)		/* called as you start to eat */
1110. 	register struct obj *otmp;
1111. {
1112. #ifdef DEBUG
1113. 	debugpline("start_eating: %lx (victual = %lx)", otmp, victual.piece);
1114. 	debugpline("reqtime = %d", victual.reqtime);
1115. 	debugpline("(original reqtime = %d)", objects[otmp->otyp].oc_delay);
1116. 	debugpline("nmod = %d", victual.nmod);
1117. 	debugpline("oeaten = %d", otmp->oeaten);
1118. #endif
1119. 	victual.fullwarn = victual.doreset = FALSE;
1120. 	victual.eating = TRUE;
1121. 
1122. 	if (otmp->otyp == CORPSE) {
1123. 	    cprefx(victual.piece->corpsenm);
1124. 	    if (!victual.piece && victual.eating) do_reset_eat();
1125. 	    if (victual.eating == FALSE) return; /* died and lifesaved */
1126. 	}
1127. 
1128. 	if (bite()) return;
1129. 
1130. 	if(++victual.usedtime >= victual.reqtime) {
1131. 	    /* print "finish eating" message if they just resumed -dlc */
1132. 	    done_eating(victual.reqtime > 1 ? TRUE : FALSE);
1133. 	    return;
1134. 	}
1135. 
1136. 	Sprintf(msgbuf, "eating %s", the(singular(otmp, xname)));
1137. 	set_occupation(eatfood, msgbuf, 0);
1138. }
1139. 
1140. 
1141. static void
1142. fprefx(otmp)		/* called on "first bite" of (non-corpse) food */
1143. 
1144. 	register struct obj *otmp;
1145. {
1146. 	switch(otmp->otyp) {
1147. 
1148. 	    case FOOD_RATION:
1149. 		if(u.uhunger <= 200)
1150. 		    if (Hallucination) pline("Oh wow, like, superior, man!");
1151. 		    else	       pline("That food really hit the spot!");
1152. 		else if(u.uhunger <= 700) pline("That satiated your stomach!");
1153. 		break;
1154. 	    case TRIPE_RATION:
1155. #ifdef POLYSELF
1156. 		if (carnivorous(uasmon) && !humanoid(uasmon))
1157. 		    pline("That tripe ration was surprisingly good!");
1158. 		else {
1159. #endif
1160. 		    pline("Yak - dog food!");
1161. 		    more_experienced(1,0);
1162. 		    flags.botl = 1;
1163. #ifdef POLYSELF
1164. 		}
1165. #endif
1166. 		if(rn2(2)
1167. #ifdef POLYSELF
1168. 			&& (!carnivorous(uasmon) || humanoid(uasmon))
1169. #endif
1170. 						) {
1171. 			make_vomiting((long)rn1(victual.reqtime, 14), FALSE);
1172. 		}
1173. 		break;
1174. #ifdef POLYSELF
1175. 	    case CLOVE_OF_GARLIC:
1176. 		if (is_undead(uasmon)) {
1177. 			make_vomiting((long)rn1(victual.reqtime, 5), FALSE);
1178. 			break;
1179. 		}
1180. 		/* Fall through otherwise */
1181. #endif
1182. 	    default:
1183. #ifdef TUTTI_FRUTTI
1184. 		if (otmp->otyp==SLIME_MOLD && !otmp->cursed
1185. 			&& otmp->spe == current_fruit)
1186. 		    pline("My, that was a yummy %s!", singular(otmp, xname));
1187. 		else
1188. #endif
1189. #ifdef UNIX
1190. 		if (otmp->otyp == APPLE || otmp->otyp == PEAR) {
1191. 		    if (!Hallucination) pline("Core dumped.");
1192. 		    else {
1193. /* This is based on an old Usenet joke, a fake a.out manual page */
1194. 			int x = rnd(100);
1195. 			if (x <= 75)
1196. 			    pline("Segmentation fault -- core dumped.");
1197. 			else if (x <= 99)
1198. 			    pline("Bus error -- core dumped.");
1199. 			else pline("Yo' mama -- core dumped.");
1200. 		    }
1201. 		} else
1202. #endif
1203. 		    pline("This %s is %s!", singular(otmp, xname),
1204. 		      otmp->cursed ? (Hallucination ? "grody" : "terrible"):
1205. 		      Hallucination ? "gnarly" :
1206. 			(otmp->otyp==CRAM_RATION ? "bland" : "delicious"));
1207. 		break;
1208. 	}
1209. }
1210. 
1211. #ifdef POLYSELF
1212. static void
1213. eatring(otmp)
1214. struct obj *otmp;
1215. {
1216. 	int typ = otmp->otyp;
1217. 	int oldprop;
1218. 
1219. 	/* Note: rings are not so common that this is unbalancing.  (How */
1220. 	/* often do you even _find_ 3 rings of polymorph in a game? */
1221. 	oldprop = !!(u.uprops[objects[typ].oc_oprop].p_flgs);
1222. 	otmp->known = otmp->dknown = 1; /* by taste */
1223. 	if (!rn2(3)) switch (otmp->otyp) {
1224. 	    case RIN_AGGRAVATE_MONSTER:
1225. 	    case RIN_WARNING:
1226. 	    case RIN_POISON_RESISTANCE:
1227. 	    case RIN_FIRE_RESISTANCE:
1228. 	    case RIN_COLD_RESISTANCE:
1229. 	    case RIN_SHOCK_RESISTANCE:
1230. 	    case RIN_TELEPORTATION:
1231. 	    case RIN_TELEPORT_CONTROL:
1232. 	    case RIN_SEE_INVISIBLE:
1233. 	    case RIN_PROTECTION_FROM_SHAPE_CHAN:
1234. 	    case RIN_SEARCHING:
1235. 	    case RIN_STEALTH:
1236. 	    case RIN_INVISIBILITY:
1237. 	    case RIN_CONFLICT:
1238. 	    case RIN_POLYMORPH:
1239. 	    case RIN_POLYMORPH_CONTROL:
1240. 	    case RIN_REGENERATION: /* Probably stupid. */
1241. 	    case RIN_HUNGER: /* Stupid. */
1242. 	    case RIN_LEVITATION: /* Stupid. */
1243. 		if (!(u.uprops[objects[typ].oc_oprop].p_flgs & FROMOUTSIDE))
1244. 		    pline("Magic spreads through your body as you digest the ring.");
1245. 		u.uprops[objects[typ].oc_oprop].p_flgs |= FROMOUTSIDE;
1246. 		if (typ == RIN_SEE_INVISIBLE) {
1247. 		    set_mimic_blocking();
1248. 		    see_monsters();
1249. 		    if (Invis && !oldprop
1250. #ifdef POLYSELF
1251. 				&& !perceives(uasmon)
1252. #endif
1253. 							&& !Blind) {
1254. 			newsym(u.ux,u.uy);
1255. 			pline("Suddenly you can see yourself.");
1256. 			makeknown(typ);
1257. 		    }
1258. 		} else if (typ == RIN_INVISIBILITY) {
1259. 		    if (!oldprop && !See_invisible && !Blind) {
1260. 			newsym(u.ux,u.uy);
1261. 			Your("body takes on a %s transparency...",
1262. 				Hallucination ? "normal" : "strange");
1263. 			makeknown(typ);
1264. 		    }
1265. 		} else if (typ == RIN_PROTECTION_FROM_SHAPE_CHAN)
1266. 		    rescham();
1267. 		else if (typ == RIN_LEVITATION) {
1268. 		    if (!Levitation) {
1269. 			float_up();
1270. 			makeknown(typ);
1271. 		    }
1272. 		}
1273. 		break;
1274. 	    case RIN_ADORNMENT:
1275. 		if (adjattrib(A_CHA, otmp->spe, -1))
1276. 		    makeknown(typ);
1277. 		break;
1278. 	    case RIN_GAIN_STRENGTH:
1279. 	    case RIN_INCREASE_DAMAGE: /* Any better ideas? */
1280. 		if (adjattrib(A_STR, otmp->spe, -1))
1281. 		    makeknown(typ);
1282. 		break;
1283. 	    case RIN_PROTECTION:
1284. 		Protection |= FROMOUTSIDE;
1285. 		u.ublessed += otmp->spe;
1286. 		flags.botl = 1;
1287. 		break;
1288. 	}
1289. }
1290. 
1291. static void
1292. eatspecial() /* called after eating non-food */
1293. {
1294. 	register struct obj *otmp = victual.piece;
1295. 
1296. 	lesshungry(victual.nmod);
1297. 	victual.piece = (struct obj *)0;
1298. 	victual.eating = 0;
1299. 	if (otmp->oclass == GOLD_CLASS) {
1300. 		dealloc_obj(otmp);
1301. 		return;
1302. 	}
1303. 	if (otmp->oclass == POTION_CLASS) {
1304. 		otmp->quan++; /* dopotion() does a useup() */
1305. 		(void)dopotion(otmp);
1306. 	}
1307. 	if (otmp->oclass == RING_CLASS)
1308. 		eatring(otmp);
1309. 	if (otmp == uball) unpunish();
1310. 	if (otmp == uchain) unpunish(); /* but no useup() */
1311. 	else if (carried(otmp)) useup(otmp);
1312. 	else useupf(otmp);
1313. }
1314. 
1315. /* NOTE: the order of these words exactly corresponds to the
1316.    order of oc_material values #define'd in objclass.h. */
1317. static const char *foodwords[] = {
1318. 	"meal", "liquid", "wax", "food", "meat",
1319. 	"paper", "cloth", "leather", "wood", "bone", "scale",
1320. 	"metal", "metal", "metal", "silver", "gold", "platinum", "mithril",
1321. 	"plastic", "glass", "rich food", "stone"
1322. };
1323. 
1324. static const char *
1325. foodword(otmp)
1326. register struct obj *otmp;
1327. {
1328. 	if (otmp->oclass == FOOD_CLASS) return "food";
1329. 	if (otmp->oclass == GEM_CLASS &&
1330. 	    objects[otmp->otyp].oc_material == GLASS &&
1331. 	    otmp->dknown)
1332. 		makeknown(otmp->otyp);
1333. 	return foodwords[objects[otmp->otyp].oc_material];
1334. }
1335. #endif
1336. 
1337. static void
1338. fpostfx(otmp)		/* called after consuming (non-corpse) food */
1339. 
1340. 	register struct obj *otmp;
1341. {
1342. 	switch(otmp->otyp) {
1343. #ifdef POLYSELF
1344. 	    case SPRIG_OF_WOLFSBANE:
1345. 		if (u.ulycn != -1) {
1346. 		    u.ulycn = -1;
1347. 		    You("feel purified.");
1348. 		    if(uasmon == &mons[u.ulycn] && !Polymorph_control)
1349. 			rehumanize();
1350. 		}
1351. 		break;
1352. #endif
1353. 	    case CARROT:
1354. 		make_blinded(0L,TRUE);
1355. 		break;
1356. 	    case FORTUNE_COOKIE:
1357. 		outrumor(bcsign(otmp), TRUE);
1358. 		break;
1359. 	    case LUMP_OF_ROYAL_JELLY:
1360. 		/* This stuff seems to be VERY healthy! */
1361. 		gainstr(otmp, 1);
1362. 		u.uhp += (otmp->cursed) ? -rnd(20) : rnd(20);
1363. 		if(u.uhp > u.uhpmax) {
1364. 			if(!rn2(17)) u.uhpmax++;
1365. 			u.uhp = u.uhpmax;
1366. 		} else if(u.uhp <= 0) {
1367. 			killer_format = KILLED_BY_AN;
1368. 			killer = "rotten lump of royal jelly";
1369. 			done(POISONING);
1370. 		}
1371. 		if(!otmp->cursed) heal_legs();
1372. 		break;
1373. 	    case EGG:
1374. 		if(otmp->corpsenm == PM_COCKATRICE) {
1375. #ifdef POLYSELF
1376. 		    if(!resists_ston(uasmon))
1377. 			if(!poly_when_stoned(uasmon) ||
1378. 			   !polymon(PM_STONE_GOLEM))
1379. 		    {
1380. #endif
1381. 			if (!Stoned) Stoned = 5;
1382. 			killer_format = KILLED_BY_AN;
1383. 			killer = "cockatrice egg";
1384. #ifdef POLYSELF
1385. 		    }
1386. #endif
1387. 		}
1388. 		break;
1389. 	}
1390. 	return;
1391. }
1392. 
1393. int
1394. doeat()		/* generic "eat" command funtion (see cmd.c) */
1395. {
1396. 	register struct obj *otmp;
1397. 	int basenutrit;			/* nutrition of full item */
1398. 
1399. 	if (Strangled) {
1400. 		pline("If you can't breathe air, how can you consume solids?");
1401. 		return 0;
1402. 	}
1403. 	if (!(otmp = floorfood("eat", 0))) return 0;
1404. 	if (check_capacity(NULL)) return 0;
1405. #ifdef POLYSELF
1406. 	/* We have to make non-foods take no time to eat, unless we want to
1407. 	 * do ridiculous amounts of coding to deal with partly eaten plate
1408. 	 * mails, players who polymorph back to human in the middle of their
1409. 	 * metallic meal, etc....
1410. 	 */
1411. 	if (!is_edible(otmp)) {
1412. 	    You("cannot eat that!");
1413. 	    return 0;
1414. 	}
1415. 	if (otmp->oclass != FOOD_CLASS) {
1416. 	    victual.reqtime = 1;
1417. 	    victual.piece = otmp;
1418. 		/* Don't split it, we don't need to if it's 1 move */
1419. 	    victual.usedtime = 0;
1420. 	    victual.canchoke = (u.uhs == SATIATED);
1421. 		/* Note: gold weighs 1 pt. for each 1000 pieces (see */
1422. 		/* pickup.c) so gold and non-gold is consistent. */
1423. 	    if (otmp->oclass == GOLD_CLASS)
1424. 		basenutrit = ((otmp->quan > 200000L) ? 2000
1425. 			: (int)(otmp->quan/100L));
1426. 	    else basenutrit = objects[otmp->otyp].oc_nutrition;
1427. 	    victual.nmod = basenutrit;
1428. 	    victual.eating = TRUE; /* needed for lesshungry() */
1429. 
1430. 	    if (otmp->cursed)
1431. 		(void) rottenfood(otmp);
1432. 
1433. 	    if (otmp->oclass == WEAPON_CLASS && otmp->opoisoned) {
1434. 		pline("Ecch - that must have been poisonous!");
1435. 		if(!Poison_resistance) {
1436. 		    losestr(rnd(4));
1437. 		    losehp(rnd(15), xname(otmp), KILLED_BY_AN);
1438. 		} else
1439. 		    You("seem unaffected by the poison.");
1440. 	    } else if (!otmp->cursed)
1441. 		pline("This %s is delicious!",
1442. 		      otmp->oclass == GOLD_CLASS ? foodword(otmp) :
1443. 		      singular(otmp, xname));
1444. 	    eatspecial();
1445. 	    return 1;
1446. 	}
1447. #endif
1448. 
1449. 	if(otmp == victual.piece) {
1450. 	/* If they weren't able to choke, they don't suddenly become able to
1451. 	 * choke just because they were interrupted.  On the other hand, if
1452. 	 * they were able to choke before, if they lost food it's possible
1453. 	 * they shouldn't be able to choke now.
1454. 	 */
1455. 	    if (u.uhs != SATIATED) victual.canchoke = FALSE;
1456. 	    if(!carried(victual.piece)) {
1457. 		if(victual.piece->quan > 1L)
1458. 			(void) splitobj(victual.piece, 1L);
1459. 	    }
1460. 	    You("resume your meal.");
1461. 	    start_eating(victual.piece);
1462. 	    return(1);
1463. 	}
1464. 
1465. 	/* nothing in progress - so try to find something. */
1466. 	/* tins are a special case */
1467. 	if(otmp->otyp == TIN) {
1468. 	    start_tin(otmp);
1469. 	    return(1);
1470. 	}
1471. 
1472. 	victual.piece = otmp = touchfood(otmp);
1473. 	victual.usedtime = 0;
1474. 
1475. 	/* Now we need to calculate delay and nutritional info.
1476. 	 * The base nutrition calculated here and in eatcorpse() accounts
1477. 	 * for normal vs. rotten food.  The reqtime and nutrit values are
1478. 	 * then adjusted in accordance with the amount of food left.
1479. 	 */
1480. 	if(otmp->otyp == CORPSE) {
1481. 	    if(eatcorpse(otmp)) return(1);
1482. 	    /* else eatcorpse sets up reqtime and oeaten */
1483. 	} else {
1484. 	    victual.reqtime = objects[otmp->otyp].oc_delay;
1485. 	    if (otmp->otyp != FORTUNE_COOKIE &&
1486. 		(otmp->cursed ||
1487. 		 (((monstermoves - otmp->age) > (int) otmp->blessed ? 50:30) &&
1488. 		(otmp->orotten || !rn2(7))))) {
1489. 
1490. #ifdef POLYSELF
1491. 		if(rottenfood(otmp)) {
1492. #else
1493. 		if(rottenfood()) {
1494. #endif
1495. 		    otmp->orotten = TRUE;
1496. 		    return(1);
1497. 		}
1498. 		otmp->oeaten >>= 1;
1499. 	    } else fprefx(otmp);
1500. 	}
1501. 
1502. 	/* re-calc the nutrition */
1503. 	if (otmp->otyp == CORPSE) basenutrit = mons[otmp->corpsenm].cnutrit;
1504. 	else basenutrit = objects[otmp->otyp].oc_nutrition;
1505. 
1506. #ifdef DEBUG
1507. 	debugpline("before rounddiv: victual.reqtime == %d", victual.reqtime);
1508. 	debugpline("oeaten == %d, basenutrit == %d", otmp->oeaten, basenutrit);
1509. #endif
1510. 	victual.reqtime = (basenutrit == 0 ? 0 :
1511. 		rounddiv(victual.reqtime * (long)otmp->oeaten, basenutrit));
1512. #ifdef DEBUG
1513. 	debugpline("after rounddiv: victual.reqtime == %d", victual.reqtime);
1514. #endif
1515. 	/* calculate the modulo value (nutrit. units per round eating)
1516. 	 * note: this isn't exact - you actually lose a little nutrition
1517. 	 *	 due to this method.
1518. 	 * TODO: add in a "remainder" value to be given at the end of the
1519. 	 *	 meal.
1520. 	 */
1521. 	if(victual.reqtime == 0)
1522. 	    /* possible if most has been eaten before */
1523. 	    victual.nmod = 0;
1524. 	else if (otmp->oeaten > victual.reqtime)
1525. 	    victual.nmod = -(otmp->oeaten / victual.reqtime);
1526. 	else
1527. 	    victual.nmod = victual.reqtime % otmp->oeaten;
1528. 	victual.canchoke = (u.uhs == SATIATED);
1529. 
1530. 	start_eating(otmp);
1531. 	return(1);
1532. }
1533. 
1534. /* Take a single bite from a piece of food, checking for choking and
1535.  * modifying usedtime.  Returns 1 if they choked and survived, 0 otherwise.
1536.  */
1537. static int
1538. bite()
1539. {
1540. 	if(victual.canchoke && u.uhunger >= 2000) {
1541. 		choke(victual.piece);
1542. 		return 1;
1543. 	}
1544. 	if (victual.doreset) {
1545. 		do_reset_eat();
1546. 		return 0;
1547. 	}
1548. 	if(victual.nmod < 0) {
1549. 		lesshungry(-victual.nmod);
1550. 		victual.piece->oeaten -= -victual.nmod;
1551. 	} else if(victual.nmod > 0 && (victual.usedtime % victual.nmod)) {
1552. 		lesshungry(1);
1553. 		victual.piece->oeaten--;
1554. 	}
1555. 	recalc_wt();
1556. 	return 0;
1557. }
1558. 
1559. #endif /* OVLB */
1560. #ifdef OVL0
1561. 
1562. void
1563. gethungry()	/* as time goes by - called by moveloop() and domove() */
1564. {
1565. 	if (u.uinvulnerable) return;	/* you don't feel hungrier */
1566. 
1567. 	if ((!u.usleep || !rn2(10))	/* slow metabolic rate while asleep */
1568. 		&& (carnivorous(uasmon) || herbivorous(uasmon)))
1569. 	    u.uhunger--;		/* ordinary food consumption */
1570. 
1571. 	if (moves % 2) {	/* odd turns */
1572. 	    /* Regeneration uses up food, unless due to an artifact */
1573. 	    if ((HRegeneration & (~W_ART)) &&
1574. 		(HRegeneration != W_WEP || !uwep->oartifact)) u.uhunger--;
1575. 	    if (near_capacity() > SLT_ENCUMBER) u.uhunger--;
1576. 	} else {		/* even turns */
1577. 	    if (Hunger) u.uhunger--;
1578. 	    /* Conflict uses up food too */
1579. 	    if ((Conflict & (~W_ARTI))) u.uhunger--;
1580. 	    /* +0 charged rings don't do anything, so don't affect hunger */
1581. 	    switch (moves % 20) {	/* note: use even cases only */
1582. 	     case  4: if (uleft &&
1583. 			  (uleft->spe || !objects[uleft->otyp].oc_charged))
1584. 			    u.uhunger--;
1585. 		    break;
1586. 	     case  8: if (uamul) u.uhunger--;
1587. 		    break;
1588. 	     case 12: if (uright &&
1589. 			  (uright->spe || !objects[uright->otyp].oc_charged))
1590. 			    u.uhunger--;
1591. 		    break;
1592. 	     case 16: if (u.uhave.amulet) u.uhunger--;
1593. 		    break;
1594. 	     default: break;
1595. 	    }
1596. 	}
1597. 	newuhs(TRUE);
1598. }
1599. 
1600. #endif /* OVL0 */
1601. #ifdef OVLB
1602. 
1603. void
1604. morehungry(num)	/* called after vomiting and after performing feats of magic */
1605. register int num;
1606. {
1607. 	u.uhunger -= num;
1608. 	newuhs(TRUE);
1609. }
1610. 
1611. 
1612. void
1613. lesshungry(num)	/* called after eating (and after drinking fruit juice) */
1614. register int num;
1615. {
1616. #ifdef DEBUG
1617. 	debugpline("lesshungry(%d)", num);
1618. #endif
1619. 	u.uhunger += num;
1620. 	if(u.uhunger >= 2000) {
1621. 	    if (!victual.eating || victual.canchoke)
1622. 		if (victual.eating) {
1623. 			choke(victual.piece);
1624. 			reset_eat();
1625. 		} else
1626. 		if (tin.tin)
1627. 			choke(tin.tin);
1628. 		else
1629. 			choke((struct obj *) 0);
1630. 		/* no reset_eat(); it was a non-food such as juice */
1631. 	} else {
1632. 	    /* Have lesshungry() report when you're nearly full so all eating
1633. 	     * warns when you're about to choke.
1634. 	     */
1635. 	    if (u.uhunger >= 1500) {
1636. 	      if(!victual.eating || (victual.eating && !victual.fullwarn)) {
1637. 		pline("You're having a hard time getting all of it down.");
1638. 		nomovemsg = "You're finally finished.";
1639. 		if(!victual.eating)
1640. 		    multi = -2;
1641. 		else {
1642. 		    victual.fullwarn = TRUE;
1643. 		    if (victual.canchoke &&
1644. 			/* a one-gulp food will not survive a stop */
1645. 				objects[victual.piece->otyp].oc_delay > 1) {
1646. 			if(yn("Stop eating?") == 'y')
1647. 			{
1648. 				reset_eat();
1649. 				nomovemsg = NULL;
1650. 			}
1651. 		    }
1652. 		}
1653. 	      }
1654. 	    }
1655. 	}
1656. 	newuhs(FALSE);
1657. }
1658. 
1659. STATIC_PTR
1660. int
1661. unfaint() {
1662. 	(void) Hear_again();
1663. 	if(u.uhs > FAINTING)
1664. 		u.uhs = FAINTING;
1665. 	stop_occupation();
1666. 	flags.botl = 1;
1667. 	return 0;
1668. }
1669. 
1670. #endif /* OVLB */
1671. #ifdef OVL0
1672. 
1673. boolean
1674. is_fainted() {
1675. 	return(u.uhs == FAINTED);
1676. }
1677. 
1678. void
1679. reset_faint() {	/* call when a faint must be prematurely terminated */
1680. 	if(is_fainted()) nomul(0);
1681. }
1682. 
1683. #if 0
1684. void
1685. sync_hunger() {
1686. 
1687. 	if(is_fainted()) {
1688. 
1689. 		flags.soundok = 0;
1690. 		nomul(-10+(u.uhunger/10));
1691. 		nomovemsg = "You regain consciousness.";
1692. 		afternmv = unfaint;
1693. 	}
1694. }
1695. #endif
1696. 
1697. void
1698. newuhs(incr)		/* compute and comment on your (new?) hunger status */
1699. 	boolean incr;
1700. {
1701. 	register int newhs, h = u.uhunger;
1702. 
1703. 	newhs = (h > 1000) ? SATIATED :
1704. 		(h > 150) ? NOT_HUNGRY :
1705. 		(h > 50) ? HUNGRY :
1706. 		(h > 0) ? WEAK : FAINTING;
1707. 
1708. 	if(newhs == FAINTING) {
1709. 		if(is_fainted()) newhs = FAINTED;
1710. 		if(u.uhs <= WEAK || rn2(20-u.uhunger/10) >= 19) {
1711. 			if(!is_fainted() && multi >= 0 /* %% */) {
1712. 				/* stop what you're doing, then faint */
1713. 				stop_occupation();
1714. 				You("faint from lack of food.");
1715. 				flags.soundok = 0;
1716. 				nomul(-10+(u.uhunger/10));
1717. 				nomovemsg = "You regain consciousness.";
1718. 				afternmv = unfaint;
1719. 				newhs = FAINTED;
1720. 			}
1721. 		} else
1722. 		if(u.uhunger < -(int)(200 + 20*ACURR(A_CON))) {
1723. 			u.uhs = STARVED;
1724. 			flags.botl = 1;
1725. 			bot();
1726. 			You("die from starvation.");
1727. 			killer_format = KILLED_BY;
1728. 			killer = "starvation";
1729. 			done(STARVING);
1730. 			/* if we return, we lifesaved, and that calls newuhs */
1731. 			return;
1732. 		}
1733. 	}
1734. 
1735. 	if(newhs != u.uhs) {
1736. 		if(newhs >= WEAK && u.uhs < WEAK)
1737. 			losestr(1);	/* this may kill you -- see below */
1738. 		else if(newhs < WEAK && u.uhs >= WEAK)
1739. 			losestr(-1);
1740. 		switch(newhs){
1741. 		case HUNGRY:
1742. 			if (Hallucination) {
1743. 			    pline((!incr) ?
1744. 				"You now have a lesser case of the munchies." :
1745. 				"You are getting the munchies.");
1746. 			} else
1747. 			    You((!incr) ? "only feel hungry now." :
1748. 				  (u.uhunger < 145) ? "feel hungry." :
1749. 				   "are beginning to feel hungry.");
1750. 			if (incr && occupation &&
1751. 			    (occupation != eatfood && occupation != opentin))
1752. 			    stop_occupation();
1753. 			break;
1754. 		case WEAK:
1755. 			if (Hallucination)
1756. 			    pline((!incr) ?
1757. 				  "You still have the munchies." :
1758.       "The munchies are interfering with your motor capabilities.");
1759. 			else
1760. 			    You((!incr) ? "feel weak now." :
1761. 				  (u.uhunger < 45) ? "feel weak." :
1762. 				   "are beginning to feel weak.");
1763. 			if (incr && occupation &&
1764. 			    (occupation != eatfood && occupation != opentin))
1765. 			    stop_occupation();
1766. 			break;
1767. 		}
1768. 		u.uhs = newhs;
1769. 		flags.botl = 1;
1770. 		if(u.uhp < 1) {
1771. 			You("die from hunger and exhaustion.");
1772. 			killer_format = KILLED_BY;
1773. 			killer = "exhaustion";
1774. 			done(STARVING);
1775. 			return;
1776. 		}
1777. 	}
1778. }
1779. 
1780. #endif /* OVL0 */
1781. #ifdef OVLB
1782. 
1783. /* Returns an object representing food.  Object may be either on floor or
1784.  * in inventory.
1785.  */
1786. struct obj *
1787. floorfood(verb,corpseonly)	/* get food from floor or pack */
1788. 	const char *verb;
1789. 	boolean corpseonly;
1790. {
1791. 	register struct obj *otmp;
1792. 	char qbuf[QBUFSZ];
1793. 	char c;
1794. #ifdef POLYSELF
1795. 	struct obj *gold = g_at(u.ux, u.uy);
1796. 	boolean feeding = (!strcmp(verb, "eat"));
1797. 
1798. 	if (feeding && gold && metallivorous(uasmon)) {
1799. 	    if (gold->quan == 1L)
1800. 		Sprintf(qbuf, "There is 1 gold piece here; eat it?");
1801. 	    else Sprintf(qbuf, "There are %ld gold pieces here; eat them?",
1802. 								gold->quan);
1803. 	    if (yn(qbuf) == 'y') {
1804. 		/* tricky, because gold isn't a real object -dlc */
1805. 		freeobj(gold);
1806. 		return gold;
1807. 	    }
1808. 	}
1809. #endif
1810. 	/* Is there some food (probably a heavy corpse) here on the ground? */
1811. 	if (!(Levitation && !Is_airlevel(&u.uz)  && !Is_waterlevel(&u.uz))
1812. 	    && !u.uswallow) {
1813. 	    for(otmp = level.objects[u.ux][u.uy]; otmp; otmp = otmp->nexthere) {
1814. 		if(corpseonly ? otmp->otyp==CORPSE :
1815. #ifdef POLYSELF
1816. 		    feeding ? (otmp->oclass != GOLD_CLASS && is_edible(otmp)) :
1817. #endif
1818. 						otmp->oclass==FOOD_CLASS) {
1819. 			Sprintf(qbuf, "There %s %s here; %s %s?",
1820. 				(otmp->quan == 1L) ? "is" : "are",
1821. 				doname(otmp), verb,
1822. 				(otmp->quan == 1L) ? "it" : "one");
1823. 			if((c = yn_function(qbuf,ynqchars,'n')) == 'y')
1824. 				return(otmp);
1825. 			else if(c == 'q')
1826. 				return((struct obj *) 0);
1827. 		}
1828. 	    }
1829. 	}
1830. #ifdef POLYSELF
1831. 	/* We cannot use ALL_CLASSES since that causes getobj() to skip its
1832. 	 * "ugly checks" and we need to check for inedible items.
1833. 	 */
1834. 	return getobj(feeding ? (const char *)allobj :
1835. 				(const char *)comestibles, verb);
1836. #else
1837. 	return getobj(comestibles, verb);
1838. #endif
1839. }
1840. 
1841. /* Side effects of vomiting */
1842. /* added nomul (MRS) - it makes sense, you're too busy being sick! */
1843. /* TO DO: regurgitate swallowed monsters when poly'd */
1844. void
1845. vomit() {		/* A good idea from David Neves */
1846. 	make_sick(0L,TRUE);
1847. 	nomul(-2);
1848. }
1849. 
1850. int
1851. eaten_stat(base, obj)
1852. register int base;
1853. register struct obj *obj;
1854. {
1855. 	long uneaten_amt, full_amount;
1856. 
1857. 	uneaten_amt = (long)obj->oeaten;
1858. 	full_amount = (obj->otyp == CORPSE) ? (long)mons[obj->corpsenm].cnutrit
1859. 					: (long)objects[obj->otyp].oc_nutrition;
1860. 
1861. 	base = (int)(full_amount ? (long)base * uneaten_amt / full_amount : 0L);
1862. 	return (base < 1) ? 1 : base;
1863. }
1864. 
1865. #endif /* OVLB */
1866. 
1867. /*eat.c*/

Also on Fandom

Random Wiki