Wikia

Wikihack

Source:NetHack 3.0.0/mondata.c

2,032pages on
this wiki
Talk0

Below is the full text to mondata.c from the source code of NetHack 3.0.0. To link to a particular line, write [[NetHack 3.0.0/mondata.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: @(#)mondata.c	3.0	89/01/10
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
5.    #include "hack.h"
6.    #include "eshk.h"
7.    #include "epri.h"
8.    
9.    /*	These routines provide basic data for any type of monster. */
10.   
11.   boolean
12.   attacktype(ptr, atyp)
13.   	register struct	permonst	*ptr;
14.   	register int atyp;
15.   {
16.   	int	i;
17.   
18.   	for(i = 0; i < NATTK; i++)
19.   	    if(ptr->mattk[i].aatyp == atyp) return(TRUE);
20.   
21.   	return(FALSE);
22.   }
23.   
24.   boolean
25.   resists_ston(ptr)	/* returns TRUE if monster is petrify resistant */
26.   	register struct permonst *ptr;
27.   {
28.   	return (ptr->mflags1 & M1_STON_RES || dmgtype(ptr, AD_STON) ||
29.   		dmgtype(ptr, AD_ACID));
30.   }
31.   
32.   boolean
33.   resists_drli(ptr)	/* returns TRUE if monster is drain-life resistant */
34.   
35.   	register struct permonst *ptr;
36.   {
37.   	return(is_undead(ptr) || is_demon(ptr) || is_were(ptr));
38.   }
39.   
40.   boolean
41.   ranged_attk(ptr)	/* returns TRUE if monster can attack at range */
42.   	register struct permonst *ptr;
43.   {
44.   	return (attacktype(ptr, AT_BREA) || attacktype(ptr, AT_WEAP) ||
45.   		attacktype(ptr, AT_SPIT) || attacktype(ptr, AT_GAZE) ||
46.   		attacktype(ptr, AT_MAGC));
47.   }
48.   
49.   boolean
50.   can_track(ptr)		/* returns TRUE if monster can track well */
51.   	register struct permonst *ptr;
52.   {
53.   #ifdef NAMED_ITEMS
54.   	if(uwep && !strcmp(ONAME(uwep), "Excalibur")) return TRUE;
55.   #endif
56.   	return(haseyes(ptr));
57.   }
58.   
59.   #ifdef POLYSELF
60.   boolean
61.   breakarm(ptr)	/* creature will break out of armor */
62.   	register struct permonst *ptr;
63.   {
64.   	return(bigmonst(ptr) || (!verysmall(ptr) && !humanoid(ptr))
65.   #ifdef HARD
66.   	       || ptr == &mons[PM_MARILITH]
67.   #endif
68.   	       );
69.   	/* Marilith is about the only case of a monster which is otherwise
70.   	 * humanoid but cannot wear armor (too many arms).  Centaurs would
71.   	 * be another except that they are already accounted for by
72.   	 * bigmonst.
73.   	 */
74.   }
75.   
76.   boolean
77.   sliparm(ptr)	/* creature will slide out of armor */
78.   	register struct permonst *ptr;
79.   {
80.   	return(!bigmonst(ptr) && (verysmall(ptr) || ptr == &mons[PM_GHOST]));
81.   }
82.   #endif
83.   
84.   boolean
85.   sticks(ptr)	/* creature sticks other creatures it hits */
86.   	register struct permonst *ptr;
87.   {
88.   	return(dmgtype(ptr,AD_STCK) || dmgtype(ptr,AD_WRAP) ||
89.   		attacktype(ptr,AT_HUGS));
90.   }
91.   
92.   /* not one hundred percent correct: now a snake may hide under an
93.    *				    invisible object.
94.    */
95.   boolean
96.   canseemon(mtmp)
97.   	register struct monst *mtmp;
98.   {
99.   	return((!mtmp->minvis || See_invisible)
100.  		&& (!mtmp->mhide ||
101.  		    (levl[mtmp->mx][mtmp->my].omask == 0 &&
102.  		     levl[mtmp->mx][mtmp->my].gmask == 0))
103.  		&& cansee(mtmp->mx, mtmp->my));
104.  }
105.  
106.  boolean
107.  dmgtype(ptr, dtyp)
108.  	register struct	permonst	*ptr;
109.  	register int dtyp;
110.  {
111.  	int	i;
112.  
113.  	for(i = 0; i < NATTK; i++)
114.  	    if(ptr->mattk[i].adtyp == dtyp) return TRUE;
115.  
116.  	return FALSE;
117.  }
118.  
119.  int
120.  monsndx(ptr)		/* return an index into the mons array */
121.  	struct	permonst	*ptr;
122.  {
123.  	register int	i;
124.  	register struct permonst *mdat;
125.  
126.  	if(ptr == &playermon) return(-1);
127.  
128.  	for(i = 0, mdat = &mons[0]; mdat->mlet; i++)
129.  	     if(ptr == mdat++) return(i);
130.  
131.  	panic("monsndx - could not index monster (%x)", ptr);
132.  	return FALSE;			   /* will not get here */
133.  }
134.  
135.  int
136.  name_to_mon(str)
137.  char *str;
138.  {
139.  	/* Be careful.  We must check the entire string in case it was
140.  	 * something such as "ettin zombie corpse".  The calling routine
141.  	 * doesn't know about the "corpse" until the monster name has
142.  	 * already been taken off the front, so we have to be able to
143.  	 * read the name with extraneous stuff such as "corpse" stuck on
144.  	 * the end.
145.  	 * This causes a problem for names which prefix other names such
146.  	 * as "ettin" on "ettin zombie".  In this case we want the _longest_
147.  	 * name which exists.
148.  	 * This also permits plurals created by adding suffixes such as 's'
149.  	 * or 'es'.  Other plurals must still be handled explicitly.
150.  	 */
151.  	register int i;
152.  	register int mntmp = -1;
153.  	register char *s;
154.  	char buf[BUFSZ];
155.  	int len=0;
156.  
157.  	Strcpy(buf, str);
158.  	str = buf;
159.  	if (!strncmp(str, "a ", 2)) str += 2;
160.  	else if (!strncmp(str, "an ", 3)) str += 3;
161.  
162.  	/* Some irregular plurals */
163.  #ifdef HARD
164.  	if (!strncmp(str, "incubi", 6)) return PM_INCUBUS;
165.  	if (!strncmp(str, "succubi", 7)) return PM_SUCCUBUS;
166.  #endif
167.  	if (!strncmp(str, "violet fungi", 12)) return PM_VIOLET_FUNGUS;
168.  	if (!strncmp(str, "homunculi", 9)) return PM_HOMUNCULUS;
169.  	if (!strncmp(str, "baluchitheria", 13)) return PM_BALUCHITHERIUM;
170.  	if (!strncmp(str, "lurkers above", 13)) return PM_LURKER_ABOVE;
171.  	if (!strncmp(str, "cavemen", 7)) return PM_CAVEMAN;
172.  	if (!strncmp(str, "cavewomen", 9)) return PM_CAVEWOMAN;
173.  	if (!strncmp(str, "zruties", 7)) return PM_ZRUTY;
174.  	if (!strncmp(str, "djinn", 5)) return PM_DJINNI;
175.  		/* be careful with "ies"; "priest", "zombies" */
176.  	for(s=str; *s; s++) {
177.  		if (!strncmp(s, "vortices", 8)) {
178.  			Strcpy(s+4, "ex");
179.  			break;
180.  		}
181.  		if (!strncmp(s, "jellies", 7) || !strncmp(s, "mummies", 7)) {
182.  			Strcpy(s+4, "y");
183.  			break;
184.  		}
185.  		if (!strncmp(s, "ves", 3)) {
186.  		/* luckily no monster names end in fe or ve with ves plurals */
187.  			Strcpy(s, "f");
188.  			break;
189.  		}
190.  	}
191.  	
192.  	for(i = 0; mons[i].mlet; i++) {
193.  		if(!strncmp(mons[i].mname, str, strlen(mons[i].mname))) {
194.  			if (strlen(mons[i].mname) > len) {
195.  				mntmp = i;
196.  				len = strlen(mons[i].mname);
197.  			}
198.  		}
199.  	}
200.  	return mntmp;
201.  }
202.  
203.  #ifdef POLYSELF
204.  boolean
205.  webmaker(ptr)   /* creature can spin a web */
206.  	register struct permonst *ptr;
207.  {
208.  	return (ptr->mlet == S_SPIDER && ptr != &mons[PM_SCORPION]);
209.  }
210.  #endif
211.  
212.  boolean
213.  is_female(mtmp)
214.  	register struct monst *mtmp;
215.  {
216.  	if (mtmp->isshk) return !ESHK(mtmp)->ismale;
217.  #if defined(ALTARS) && defined(THEOLOGY)
218.  	if (mtmp->ispriest) return !EPRI(mtmp)->ismale;
219.  #endif
220.  	return !!(mtmp->data->mflags1 & M1_FEM);
221.  }
222.  
223.  /* Gender function.  Differs from is_female() in that 1) It allows the monster
224.   * type of a polymorphed shopkeeper to override ESHK(mtmp)->ismale, and 2)
225.   * it returns 3 values (0=male, 1=female, 2=none) instead of 2.
226.   */
227.  int
228.  gender(mtmp)
229.  	register struct monst *mtmp;
230.  {
231.  	if (!humanoid(mtmp->data)) return 2;
232.  	if (mtmp->data->mflags1 & M1_FEM) return 1;
233.  	if (mtmp->data == &mons[PM_CAVEMAN]
234.  		|| mtmp->data == &mons[PM_PRIEST]
235.  #ifdef HARD
236.  		|| mtmp->data == &mons[PM_INCUBUS]
237.  #endif
238.  						) return 0;
239.  #if defined(ALTARS) && defined(THEOLOGY)
240.  	if (mtmp->ispriest) return !EPRI(mtmp)->ismale;
241.  #endif
242.  	if (mtmp->isshk) return !ESHK(mtmp)->ismale;
243.  	return 0;
244.  }
245.  
246.  boolean
247.  levl_follower(mtmp)
248.  register struct monst *mtmp;
249.  {
250.  	return (mtmp->mtame || (mtmp->data->mflags1 & M1_STALK) || is_fshk(mtmp)
251.  		|| (mtmp->iswiz && !mon_has_amulet(mtmp)));
252.  }
253.  
254.  struct permonst *
255.  player_mon()
256.  {
257.  	switch (pl_character[0]) {
258.  		case 'A': return &mons[PM_ARCHEOLOGIST];
259.  		case 'B': return &mons[PM_BARBARIAN];
260.  		case 'C': if (flags.female) return &mons[PM_CAVEWOMAN];
261.  			else return &mons[PM_CAVEMAN];
262.  		case 'E': return &mons[PM_ELF];
263.  		case 'H': return &mons[PM_HEALER];
264.  		case 'K': return &mons[PM_KNIGHT];
265.  		case 'P': if (flags.female) return &mons[PM_PRIESTESS];
266.  			else return &mons[PM_PRIEST];
267.  		case 'R': return &mons[PM_ROGUE];
268.  		case 'S': return &mons[PM_SAMURAI];
269.  		case 'T': return &mons[PM_TOURIST];
270.  		case 'V': return &mons[PM_VALKYRIE];
271.  		case 'W': return &mons[PM_WIZARD];
272.  		default: impossible("what are you?");
273.  			return &mons[PM_HUMAN];
274.  	}
275.  }
276.  
277.  const int grownups[][2] = { {PM_LITTLE_DOG, PM_DOG}, {PM_DOG, PM_LARGE_DOG},
278.  	{PM_HELL_HOUND_PUP, PM_HELL_HOUND}, {PM_KITTEN, PM_HOUSECAT},
279.  	{PM_HOUSECAT, PM_LARGE_CAT}, {PM_BABY_GREY_DRAGON, PM_GREY_DRAGON},
280.  	{PM_BABY_RED_DRAGON, PM_RED_DRAGON},
281.  	{PM_BABY_WHITE_DRAGON, PM_WHITE_DRAGON},
282.  	{PM_BABY_BLUE_DRAGON, PM_BLUE_DRAGON},
283.  	{PM_BABY_GREEN_DRAGON, PM_GREEN_DRAGON},
284.  	{PM_BABY_ORANGE_DRAGON, PM_ORANGE_DRAGON},
285.  	{PM_BABY_BLACK_DRAGON, PM_BLACK_DRAGON},
286.  	{PM_BABY_YELLOW_DRAGON, PM_YELLOW_DRAGON},
287.  	{PM_RED_NAGA_HATCHLING, PM_RED_NAGA},
288.  	{PM_BLACK_NAGA_HATCHLING, PM_BLACK_NAGA},
289.  	{PM_GOLDEN_NAGA_HATCHLING, PM_GOLDEN_NAGA},
290.  	{PM_GUARDIAN_NAGA_HATCHLING, PM_GUARDIAN_NAGA},
291.  	{PM_BABY_PURPLE_WORM, PM_PURPLE_WORM},
292.  #ifdef WORM
293.  	{PM_BABY_LONG_WORM, PM_LONG_WORM},
294.  #endif
295.  #ifdef ARMY
296.  	{PM_SOLDIER, PM_SERGEANT},
297.  	{PM_SERGEANT, PM_LIEUTENANT},
298.  	{PM_LIEUTENANT, PM_CAPTAIN},
299.  #endif
300.  	{-1,-1}
301.  };
302.  
303.  int little_to_big(montype)
304.  int montype;
305.  {
306.  	register int *i;
307.  	
308.  	for(i=grownups[0]; *i >= 0; i++)
309.  		if(montype == *i) return *(i+1);
310.  	return montype;
311.  }
312.  
313.  int big_to_little(montype)
314.  int montype;
315.  {
316.  	register int *i;
317.  	
318.  	for(i=grownups[0]; *i >= 0; i++)
319.  		if(montype == *(i+1)) return *i;
320.  	return montype;
321.  }
322.  
323.  
324.  #ifdef STUPID_CPP	/* otherwise these functions are macros in mondata.h */
325.  
326.  int
327.  bigmonst(ptr) struct permonst *ptr; {
328.  	return((ptr->mflags1 & M1_BIG) != 0L);
329.  }
330.  
331.  int
332.  verysmall(ptr) struct permonst *ptr; {
333.  	return((ptr->mflags1 & M1_VSMALL) != 0L);
334.  }
335.  
336.  int
337.  is_flyer(ptr) struct permonst *ptr; {
338.  	return((ptr->mflags1 & M1_FLY) != 0L);
339.  }
340.  
341.  int
342.  is_floater(ptr) struct permonst *ptr; {
343.  	return(ptr->mlet == S_EYE);
344.  }
345.  
346.  int
347.  is_swimmer(ptr) struct permonst *ptr; {
348.  	return((ptr->mflags1 & M1_SWIM) != 0L);
349.  }
350.  
351.  int
352.  passes_walls(ptr) struct permonst *ptr; {
353.  	return((ptr->mflags1 & M1_WALLWALK) != 0L);
354.  }
355.  
356.  int
357.  noncorporeal(ptr) struct permonst *ptr; {
358.  	return(ptr->mlet == S_GHOST);
359.  }
360.  
361.  int
362.  is_animal(ptr) struct permonst *ptr; {
363.  	return((ptr->mflags1 & M1_ANIMAL) != 0L);
364.  }
365.  
366.  int
367.  humanoid(ptr) struct permonst *ptr; {
368.  	return((ptr->mflags1 & M1_HUMANOID) != 0L);
369.  }
370.  
371.  int
372.  is_undead(ptr) struct permonst *ptr; {
373.  	return((ptr->mflags1 & M1_UNDEAD) != 0L);
374.  }
375.  
376.  int
377.  is_were(ptr) struct permonst *ptr; {
378.  	return((ptr->mflags1 & M1_WERE) != 0L);
379.  }
380.  
381.  int haseyes(ptr) struct permonst *ptr; {
382.  	return((ptr->mflags1 & M1_NOEYES) == 0L);
383.  }
384.  
385.  int
386.  nohands(ptr) struct permonst *ptr; {
387.  	return((ptr->mflags1 & M1_NOHANDS) != 0L);
388.  }
389.  
390.  int
391.  lays_eggs(ptr) struct permonst *ptr; {
392.  	return((ptr->mflags1 & M1_EGGS) != 0L);
393.  }
394.  
395.  int
396.  poisonous(ptr) struct permonst *ptr; {
397.  	return((ptr->mflags1 & M1_POIS) != 0L);
398.  }
399.  
400.  int
401.  resists_poison(ptr) struct permonst *ptr; {
402.  	return((ptr->mflags1 & (M1_POIS | M1_POIS_RES)) != 0L);
403.  }
404.  
405.  int
406.  resists_fire(ptr) struct permonst *ptr; {
407.  	return((ptr->mflags1 & M1_FIRE_RES) != 0L);
408.  }
409.  
410.  int
411.  resists_cold(ptr) struct permonst *ptr; {
412.  	return((ptr->mflags1 & M1_COLD_RES) != 0L);
413.  }
414.  
415.  int
416.  resists_acid(ptr) struct permonst *ptr; {
417.  	return(dmgtype(ptr, AD_ACID));
418.  }
419.  
420.  int
421.  resists_elec(ptr) struct permonst *ptr; {
422.  	return((ptr->mflags1 & M1_ELEC_RES) != 0L);
423.  }
424.  
425.  int
426.  resists_sleep(ptr) struct permonst *ptr; {
427.  	return((ptr->mflags1 & (M1_SLEE_RES | M1_UNDEAD)) != 0L);
428.  }
429.  
430.  int
431.  resists_disint(ptr) struct permonst *ptr; {
432.  	return(ptr == &mons[PM_BLACK_DRAGON] ||
433.  		ptr == &mons[PM_BABY_BLACK_DRAGON]);
434.  }
435.  
436.  int
437.  regenerates(ptr) struct permonst *ptr; {
438.  	return((ptr->mflags1 & M1_REGEN) != 0L);
439.  }
440.  
441.  int
442.  perceives(ptr) struct permonst *ptr; {
443.  	return((ptr->mflags1 & M1_SEE_INVIS) != 0L);
444.  }
445.  
446.  int
447.  can_teleport(ptr) struct permonst *ptr; {
448.  	return((ptr->mflags1 & M1_TPORT) != 0L);
449.  }
450.  
451.  int
452.  control_teleport(ptr) struct permonst *ptr; {
453.  	return((ptr->mflags1 & M1_TPORT_CONTROL) != 0L);
454.  }
455.  
456.  int
457.  is_armed(ptr) struct permonst *ptr; {
458.  	return(attacktype(ptr, AT_WEAP));
459.  }
460.  
461.  int
462.  likes_gold(ptr) struct permonst *ptr; {
463.  	return((ptr->mflags1 & M1_GREEDY) != 0L);
464.  }
465.  
466.  int
467.  likes_gems(ptr) struct permonst *ptr; {
468.  	return((ptr->mflags1 & M1_JEWELS) != 0L);
469.  }
470.  
471.  int
472.  likes_objs(ptr) struct permonst *ptr; {
473.  	return((ptr->mflags1 & M1_COLLECT) != 0L || is_armed(ptr));
474.  }
475.  
476.  int
477.  likes_magic(ptr) struct permonst *ptr; {
478.  	return((ptr->mflags1 & M1_MAGIC) != 0L);
479.  }
480.  
481.  int
482.  hides_under(ptr) struct permonst *ptr; {
483.  	return((ptr->mflags2 & M2_CONCEAL) != 0L);
484.  }
485.  
486.  int
487.  is_hider(ptr) struct permonst *ptr; {
488.  	return((ptr->mflags2 & M2_HIDE) != 0L);
489.  }
490.  
491.  # ifdef POLYSELF
492.  int
493.  polyok(ptr) struct permonst *ptr; {
494.  	return((ptr->mflags1 & M1_NOPOLY) == 0L);
495.  }
496.  # endif /* POLYSELF */
497.  
498.  int
499.  tunnels(ptr) struct permonst *ptr; {
500.  	return((ptr->mflags2 & M2_TUNNEL) != 0L);
501.  }
502.  
503.  int
504.  needspick(ptr) struct permonst *ptr; {
505.  	return((ptr->mflags2 & M2_NEEDPICK) != 0L);
506.  }
507.  
508.  int
509.  is_elf(ptr) struct permonst *ptr; {
510.  	return((ptr->mflags2 & M2_ELF) != 0L);
511.  }
512.  
513.  int
514.  is_dwarf(ptr) struct permonst *ptr; {
515.  	return((ptr->mflags2 & M2_DWARF) != 0L);
516.  }
517.  
518.  int
519.  is_giant(ptr) struct permonst *ptr; {
520.  	return((ptr->mflags2 & M2_GIANT) != 0L);
521.  }
522.  
523.  # ifdef GOLEMS
524.  int
525.  is_golem(ptr) struct permonst *ptr; {
526.  	return(ptr->mlet == S_GOLEM);
527.  }
528.  # endif /* GOLEMS */
529.  
530.  int
531.  is_orc(ptr) struct permonst *ptr; {
532.  	return((ptr->mflags2 & M2_ORC) != 0L);
533.  }
534.  
535.  int
536.  is_human(ptr) struct permonst *ptr; {
537.  	return((ptr->mflags2 & M2_HUMAN) != 0L);
538.  }
539.  
540.  int
541.  is_demon(ptr) struct permonst *ptr; {
542.  	return((ptr->mflags2 & M2_DEMON) != 0L);
543.  }
544.  
545.  int
546.  is_mercenary(ptr) struct permonst *ptr; {
547.  	return((ptr->mflags2 & M2_MERC) != 0L);
548.  }
549.  
550.  int
551.  throws_rocks(ptr) struct permonst *ptr; {
552.  	return((ptr->mflags2 & M2_ROCKTHROW) != 0L);
553.  }
554.  
555.  int
556.  is_wanderer(ptr) struct permonst *ptr; {
557.  	return((ptr->mflags2 & M2_WANDER) != 0L);
558.  }
559.  
560.  int
561.  is_lord(ptr) struct permonst *ptr; {
562.  	return((ptr->mflags1 & M1_LORD) != 0L);
563.  }
564.  
565.  int
566.  is_prince(ptr) struct permonst *ptr; {
567.  	return((ptr->mflags1 & M1_PRINCE) != 0L);
568.  }
569.  
570.  # ifdef HARD
571.  int
572.  is_ndemon(ptr) struct permonst *ptr; {
573.  	return(is_demon(ptr) &&
574.  		(ptr->mflags1 & (M1_LORD | M1_PRINCE)) == 0L);
575.  }
576.  # else /* HARD */
577.  int
578.  is_ndemon(ptr) struct permonst *ptr; {
579.  	return(ptr == &mons[PM_DEMON]);
580.  }
581.  # endif /* HARD */
582.  
583.  int
584.  is_dlord(ptr) struct permonst *ptr; {
585.  	return(is_demon(ptr) && is_lord(ptr));
586.  }
587.  
588.  int
589.  is_dprince(ptr) struct permonst *ptr; {
590.  	return(is_demon(ptr) && is_prince(ptr));
591.  }
592.  
593.  int
594.  type_is_pname(ptr) struct permonst *ptr; {
595.  	return((ptr->mflags2 & M2_PNAME) != 0L);
596.  }
597.  
598.  int
599.  always_hostile(ptr) struct permonst *ptr; {
600.  	return((ptr->mflags2 & M2_HOSTILE) != 0L);
601.  }
602.  
603.  int
604.  always_peaceful(ptr) struct permonst *ptr; {
605.  	return((ptr->mflags2 & M2_PEACEFUL) != 0L);
606.  }
607.  
608.  int
609.  strongmonst(ptr) struct permonst *ptr; {
610.  	return((ptr->mflags2 & M2_STRONG) != 0L);
611.  }
612.  
613.  int
614.  extra_nasty(ptr) struct permonst *ptr; {
615.  	return((ptr->mflags2 & M2_NASTY) != 0L);
616.  }
617.  
618.  # ifdef POLYSELF
619.  int
620.  can_breathe(ptr) struct permonst *ptr; {
621.  	return(attacktype(ptr, AT_BREA));
622.  }
623.  
624.  int
625.  cantwield(ptr) struct permonst *ptr; {
626.  	return(nohands(ptr) || verysmall(ptr));
627.  }
628.  
629.  int
630.  cantweararm(ptr) struct permonst *ptr; {
631.  	return(breakarm(ptr) || sliparm(ptr));
632.  }
633.  
634.  int
635.  nolimbs(ptr) struct permonst *ptr; {
636.  	return((ptr->mflags2 & M2_NOLIMBS) != 0L);
637.  }
638.  # endif /* POLYSELF */
639.  
640.  int
641.  carnivorous(ptr) struct permonst *ptr; {
642.  	return((ptr->mflags2 & M2_CARNIVORE) != 0L);
643.  }
644.  
645.  int
646.  herbivorous(ptr) struct permonst *ptr; {
647.  	return((ptr->mflags2 & M2_HERBIVORE) != 0L);
648.  }
649.  
650.  int
651.  thick_skinned(ptr) struct permonst *ptr; {
652.  	return((ptr->mflags2 & M2_THICK_HIDE) != 0L);
653.  }
654.  
655.  int
656.  amorphous(ptr) struct permonst *ptr; {
657.  	return((ptr->mflags2 & M2_AMORPHOUS) != 0L);
658.  }
659.  
660.  #endif /* STUPID_CPP */

Around Wikia's network

Random Wiki