Fandom

Wikihack

Source:SLASH'EM 0.0.7E7F2/mondata.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 mondata.c from the source code of SLASH'EM 0.0.7E7F2. To link to a particular line, write [[SLASH'EM 0.0.7E7F2/mondata.c#line123]], for example.

The latest source code for vanilla NetHack is at Source code.


The NetHack General Public License applies to screenshots, source code and other content from NetHack.
1.    /*	SCCS Id: @(#)mondata.c	3.4	2003/06/02	*/
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.   #ifdef OVLB
12.   
13.   void
14.   set_mon_data(mon, ptr, flag)
15.   struct monst *mon;
16.   struct permonst *ptr;
17.   int flag;
18.   {
19.       mon->data = ptr;
20.       if (flag == -1) return;		/* "don't care" */
21.   
22.       if (flag == 1)
23.   	mon->mintrinsics |= (ptr->mresists & MR_TYPEMASK);
24.       else
25.   	mon->mintrinsics = (ptr->mresists & MR_TYPEMASK);
26.       return;
27.   }
28.   
29.   #endif /* OVLB */
30.   #ifdef OVL0
31.   
32.   struct attack *
33.   attacktype_fordmg(ptr, atyp, dtyp)
34.   struct permonst *ptr;
35.   int atyp, dtyp;
36.   {
37.       struct attack *a;
38.   
39.       for (a = &ptr->mattk[0]; a < &ptr->mattk[NATTK]; a++)
40.   	if (a->aatyp == atyp && (dtyp == AD_ANY || a->adtyp == dtyp))
41.   	    return a;
42.   
43.       return (struct attack *)0;
44.   }
45.   
46.   boolean
47.   attacktype(ptr, atyp)
48.   struct permonst *ptr;
49.   int atyp;
50.   {
51.       return attacktype_fordmg(ptr, atyp, AD_ANY) ? TRUE : FALSE;
52.   }
53.   
54.   #endif /* OVL0 */
55.   #ifdef OVLB
56.   
57.   boolean
58.   poly_when_stoned(ptr)
59.       struct permonst *ptr;
60.   {
61.       return((boolean)(is_golem(ptr) && ptr != &mons[PM_STONE_GOLEM] &&
62.   	    !(mvitals[PM_STONE_GOLEM].mvflags & G_GENOD)));
63.   	    /* allow G_EXTINCT */
64.   }
65.   
66.   boolean
67.   resists_drli(mon)	/* returns TRUE if monster is drain-life resistant */
68.   struct monst *mon;
69.   {
70.   	struct permonst *ptr = mon->data;
71.   	struct obj *wep = ((mon == &youmonst) ? uwep : MON_WEP(mon));
72.   
73.   	return (boolean)(is_undead(ptr) || is_demon(ptr) || is_were(ptr) ||
74.   			 ptr == &mons[PM_DEATH] || is_golem(ptr) ||
75.   			 resists_drain(mon) ||
76.   			 (wep && wep->oartifact && defends(AD_DRLI, wep)));
77.   }
78.   
79.   boolean
80.   resists_magm(mon)	/* TRUE if monster is magic-missile resistant */
81.   struct monst *mon;
82.   {
83.   	struct permonst *ptr = mon->data;
84.   	struct obj *o;
85.   
86.   	/* as of 3.2.0:  gray dragons, Angels, Oracle, Yeenoghu */
87.   	if (dmgtype(ptr, AD_MAGM) || ptr == &mons[PM_BABY_GRAY_DRAGON] ||
88.   		dmgtype(ptr, AD_RBRE))	/* Chromatic Dragon */
89.   	    return TRUE;
90.   	/* check for magic resistance granted by wielded weapon */
91.   	o = (mon == &youmonst) ? uwep : MON_WEP(mon);
92.   	if (o && o->oartifact && defends(AD_MAGM, o))
93.   	    return TRUE;
94.   	/* check for magic resistance granted by worn or carried items */
95.   	o = (mon == &youmonst) ? invent : mon->minvent;
96.   	for ( ; o; o = o->nobj)
97.   	    if ((o->owornmask && objects[o->otyp].oc_oprop == ANTIMAGIC) ||
98.   		    (o->oartifact && protects(AD_MAGM, o)))
99.   		return TRUE;
100.  	return FALSE;
101.  }
102.  
103.  /* TRUE iff monster is resistant to light-induced blindness */
104.  boolean
105.  resists_blnd(mon)
106.  struct monst *mon;
107.  {
108.  	struct permonst *ptr = mon->data;
109.  	boolean is_you = (mon == &youmonst);
110.  	struct obj *o;
111.  
112.  	if (is_you ? (Blind || u.usleep) :
113.  		(mon->mblinded || !mon->mcansee || !haseyes(ptr) ||
114.  		    /* BUG: temporary sleep sets mfrozen, but since
115.  			    paralysis does too, we can't check it */
116.  		    mon->msleeping))
117.  	    return TRUE;
118.  	/* yellow light, Archon; !dust vortex, !cobra, !raven */
119.  	if (dmgtype_fromattack(ptr, AD_BLND, AT_EXPL) ||
120.  		dmgtype_fromattack(ptr, AD_BLND, AT_GAZE))
121.  	    return TRUE;
122.  	o = is_you ? uwep : MON_WEP(mon);
123.  	if (o && o->oartifact && defends(AD_BLND, o))
124.  	    return TRUE;
125.  	o = is_you ? invent : mon->minvent;
126.  	for ( ; o; o = o->nobj)
127.  	    if ((o->owornmask && objects[o->otyp].oc_oprop == BLINDED) ||
128.  		    (o->oartifact && protects(AD_BLND, o)))
129.  		return TRUE;
130.  	return FALSE;
131.  }
132.  
133.  /* TRUE iff monster can be blinded by the given attack */
134.  /* Note: may return TRUE when mdef is blind (e.g. new cream-pie attack) */
135.  boolean
136.  can_blnd(magr, mdef, aatyp, obj)
137.  struct monst *magr;		/* NULL == no specific aggressor */
138.  struct monst *mdef;
139.  uchar aatyp;
140.  struct obj *obj;		/* aatyp == AT_WEAP, AT_SPIT */
141.  {
142.  	boolean is_you = (mdef == &youmonst);
143.  	boolean check_visor = FALSE;
144.  	struct obj *o;
145.  	const char *s;
146.  
147.  	/* no eyes protect against all attacks for now */
148.  	if (!haseyes(mdef->data))
149.  	    return FALSE;
150.  
151.  	switch(aatyp) {
152.  	case AT_EXPL: case AT_BOOM: case AT_GAZE: case AT_MAGC:
153.  	case AT_BREA: /* assumed to be lightning */
154.  	    /* light-based attacks may be cancelled or resisted */
155.  	    if (magr && magr->mcan)
156.  		return FALSE;
157.  	    return !resists_blnd(mdef);
158.  
159.  	case AT_WEAP: case AT_SPIT: case AT_NONE:
160.  	    /* an object is used (thrown/spit/other) */
161.  	    if (obj && (obj->otyp == CREAM_PIE)) {
162.  		if (is_you && Blindfolded)
163.  		    return FALSE;
164.  	    } else if (obj && (obj->otyp == BLINDING_VENOM)) {
165.  		/* all ublindf, including LENSES, protect, cream-pies too */
166.  		if (is_you && (ublindf || u.ucreamed))
167.  		    return FALSE;
168.  		check_visor = TRUE;
169.  	    } else if (obj && (obj->otyp == POT_BLINDNESS)) {
170.  		return TRUE;	/* no defense */
171.  	    } else
172.  		return FALSE;	/* other objects cannot cause blindness yet */
173.  	    if ((magr == &youmonst) && u.uswallow)
174.  		return FALSE;	/* can't affect eyes while inside monster */
175.  	    break;
176.  
177.  	case AT_ENGL:
178.  	    if (is_you && (Blindfolded || u.usleep || u.ucreamed))
179.  		return FALSE;
180.  	    if (!is_you && mdef->msleeping)
181.  		return FALSE;
182.  	    break;
183.  
184.  	case AT_CLAW:
185.  	    /* e.g. raven: all ublindf, including LENSES, protect */
186.  	    if (is_you && ublindf)
187.  		return FALSE;
188.  	    if ((magr == &youmonst) && u.uswallow)
189.  		return FALSE;	/* can't affect eyes while inside monster */
190.  	    check_visor = TRUE;
191.  	    break;
192.  
193.  	case AT_TUCH: case AT_STNG:
194.  	    /* some physical, blind-inducing attacks can be cancelled */
195.  	    if (magr && magr->mcan)
196.  		return FALSE;
197.  	    break;
198.  
199.  	default:
200.  	    break;
201.  	}
202.  
203.  	/* check if wearing a visor (only checked if visor might help) */
204.  	if (check_visor) {
205.  	    o = (mdef == &youmonst) ? invent : mdef->minvent;
206.  	    for ( ; o; o = o->nobj)
207.  		if ((o->owornmask & W_ARMH) &&
208.  		    (s = OBJ_DESCR(objects[o->otyp])) != (char *)0 &&
209.  		    !strcmp(s, "visored helmet"))
210.  		    return FALSE;
211.  	}
212.  
213.  	return TRUE;
214.  }
215.  
216.  #endif /* OVLB */
217.  #ifdef OVL0
218.  
219.  boolean
220.  ranged_attk(ptr)	/* returns TRUE if monster can attack at range */
221.  struct permonst *ptr;
222.  {
223.  	register int i, atyp;
224.  	long atk_mask = (1L << AT_BREA) | (1L << AT_SPIT) | (1L << AT_GAZE);
225.  
226.  	/* was: (attacktype(ptr, AT_BREA) || attacktype(ptr, AT_WEAP) ||
227.  		attacktype(ptr, AT_SPIT) || attacktype(ptr, AT_GAZE) ||
228.  		attacktype(ptr, AT_MAGC));
229.  	   but that's too slow -dlc
230.  	 */
231.  	for(i = 0; i < NATTK; i++) {
232.  	    atyp = ptr->mattk[i].aatyp;
233.  	    if (atyp >= AT_WEAP) return TRUE;
234.  	 /* assert(atyp < 32); */
235.  	    if ((atk_mask & (1L << atyp)) != 0L) return TRUE;
236.  	}
237.  
238.  	return FALSE;
239.  }
240.  
241.  /* true iff the type of monster pass through iron bars */
242.  boolean
243.  passes_bars(mptr)
244.  struct permonst *mptr;
245.  {
246.      return (boolean) (passes_walls(mptr) || amorphous(mptr) ||
247.  		      is_whirly(mptr) || verysmall(mptr) ||
248.  		      (slithy(mptr) && !bigmonst(mptr)));
249.  }
250.  
251.  #endif /* OVL0 */
252.  #ifdef OVL1
253.  
254.  boolean
255.  can_track(ptr)		/* returns TRUE if monster can track well */
256.  	register struct permonst *ptr;
257.  {
258.  	if (uwep && uwep->oartifact == ART_EXCALIBUR)
259.  		return TRUE;
260.  	else
261.  		return((boolean)haseyes(ptr));
262.  }
263.  
264.  #endif /* OVL1 */
265.  #ifdef OVLB
266.  
267.  boolean
268.  sliparm(ptr)	/* creature will slide out of armor */
269.  	register struct permonst *ptr;
270.  {
271.  	return((boolean)(is_whirly(ptr) || ptr->msize <= MZ_SMALL ||
272.  			 noncorporeal(ptr)));
273.  }
274.  
275.  boolean
276.  breakarm(ptr)	/* creature will break out of armor */
277.  	register struct permonst *ptr;
278.  {
279.  	return ((bigmonst(ptr) || (ptr->msize > MZ_SMALL && !humanoid(ptr)) ||
280.  		/* special cases of humanoids that cannot wear body armor */
281.  		ptr == &mons[PM_MARILITH] || ptr == &mons[PM_WINGED_GARGOYLE])
282.  	      && !sliparm(ptr));
283.  }
284.  #endif /* OVLB */
285.  #ifdef OVL1
286.  
287.  boolean
288.  sticks(ptr)	/* creature sticks other creatures it hits */
289.  	register struct permonst *ptr;
290.  {
291.  	return((boolean)(dmgtype(ptr,AD_STCK) || dmgtype(ptr,AD_WRAP) ||
292.  		attacktype(ptr,AT_HUGS)));
293.  }
294.  
295.  /* number of horns this type of monster has on its head */
296.  int
297.  num_horns(ptr)
298.  struct permonst *ptr;
299.  {
300.      switch (monsndx(ptr)) {
301.      case PM_LAMB:
302.      case PM_SHEEP:
303.      case PM_GOAT:
304.      case PM_COW:
305.      case PM_BULL:
306.      case PM_HORNED_DEVIL:	/* ? "more than one" */
307.      case PM_MINOTAUR:
308.      case PM_ASMODEUS:
309.      case PM_BALROG:
310.  	return 2;
311.      case PM_WHITE_UNICORN:
312.      case PM_GRAY_UNICORN:
313.      case PM_BLACK_UNICORN:
314.      case PM_KI_RIN:
315.  	return 1;
316.      default:
317.  	break;
318.      }
319.      return 0;
320.  }
321.  
322.  struct attack *
323.  dmgtype_fromattack(ptr, dtyp, atyp)
324.  struct permonst *ptr;
325.  int dtyp, atyp;
326.  {
327.      struct attack *a;
328.  
329.      for (a = &ptr->mattk[0]; a < &ptr->mattk[NATTK]; a++)
330.  	if (a->adtyp == dtyp && (atyp == AT_ANY || a->aatyp == atyp))
331.  	    return a;
332.  
333.      return (struct attack *)0;
334.  }
335.  
336.  boolean
337.  dmgtype(ptr, dtyp)
338.  struct permonst *ptr;
339.  int dtyp;
340.  {
341.      return dmgtype_fromattack(ptr, dtyp, AT_ANY) ? TRUE : FALSE;
342.  }
343.  
344.  /* returns the maximum damage a defender can do to the attacker via
345.   * a passive defense */
346.  int
347.  max_passive_dmg(mdef, magr)
348.      register struct monst *mdef, *magr;
349.  {
350.      int	i, dmg = 0;
351.      uchar adtyp;
352.  
353.      for(i = 0; i < NATTK; i++)
354.  	if(mdef->data->mattk[i].aatyp == AT_NONE ||
355.  		mdef->data->mattk[i].aatyp == AT_BOOM) {
356.  	    adtyp = mdef->data->mattk[i].adtyp;
357.  	    if ((adtyp == AD_ACID && !resists_acid(magr)) ||
358.  		    (adtyp == AD_COLD && !resists_cold(magr)) ||
359.  		    (adtyp == AD_FIRE && !resists_fire(magr)) ||
360.  		    (adtyp == AD_ELEC && !resists_elec(magr)) ||
361.  		    adtyp == AD_PHYS) {
362.  		dmg = mdef->data->mattk[i].damn;
363.  		if(!dmg) dmg = mdef->data->mlevel+1;
364.  		dmg *= mdef->data->mattk[i].damd;
365.  	    } else dmg = 0;
366.  
367.  	    return dmg;
368.  	}
369.      return 0;
370.  }
371.  
372.  #endif /* OVL1 */
373.  #ifdef OVL0
374.  
375.  int
376.  monsndx(ptr)		/* return an index into the mons array */
377.  	struct	permonst	*ptr;
378.  {
379.  	register int	i;
380.  
381.  	if (ptr == &upermonst) return PM_PLAYERMON;
382.  
383.  	i = (int)(ptr - &mons[0]);
384.  	if (i < LOW_PM || i >= NUMMONS) {
385.  		/* ought to switch this to use `fmt_ptr' */
386.  	    panic("monsndx - could not index monster (%d)",
387.  		  i);
388.  	    return NON_PM;		/* will not get here */
389.  	}
390.  
391.  	return(i);
392.  }
393.  
394.  #endif /* OVL0 */
395.  #ifdef OVL1
396.  
397.  
398.  int
399.  name_to_mon(in_str)
400.  const char *in_str;
401.  {
402.  	/* Be careful.  We must check the entire string in case it was
403.  	 * something such as "ettin zombie corpse".  The calling routine
404.  	 * doesn't know about the "corpse" until the monster name has
405.  	 * already been taken off the front, so we have to be able to
406.  	 * read the name with extraneous stuff such as "corpse" stuck on
407.  	 * the end.
408.  	 * This causes a problem for names which prefix other names such
409.  	 * as "ettin" on "ettin zombie".  In this case we want the _longest_
410.  	 * name which exists.
411.  	 * This also permits plurals created by adding suffixes such as 's'
412.  	 * or 'es'.  Other plurals must still be handled explicitly.
413.  	 */
414.  	register int i;
415.  	register int mntmp = NON_PM;
416.  	register char *s, *str, *term;
417.  	char buf[BUFSZ];
418.  	int len, slen;
419.  
420.  	str = strcpy(buf, in_str);
421.  
422.  	if (!strncmp(str, "a ", 2)) str += 2;
423.  	else if (!strncmp(str, "an ", 3)) str += 3;
424.  
425.  	slen = strlen(str);
426.  	term = str + slen;
427.  
428.  	if ((s = strstri(str, "vortices")) != 0)
429.  	    Strcpy(s+4, "ex");
430.  	/* be careful with "ies"; "priest", "zombies" */
431.  	else if (slen > 3 && !strcmpi(term-3, "ies") &&
432.  		    (slen < 7 || strcmpi(term-7, "zombies")))
433.  	    Strcpy(term-3, "y");
434.  	/* luckily no monster names end in fe or ve with ves plurals */
435.  	else if (slen > 3 && !strcmpi(term-3, "ves"))
436.  	    Strcpy(term-3, "f");
437.  
438.  	slen = strlen(str); /* length possibly needs recomputing */
439.  
440.      {
441.  	static const struct alt_spl { const char* name; short pm_val; }
442.  	    names[] = {
443.  	    /* Alternate spellings */
444.  		{ "grey dragon",	PM_GRAY_DRAGON },
445.  		{ "baby grey dragon",	PM_BABY_GRAY_DRAGON },
446.  		{ "grey unicorn",	PM_GRAY_UNICORN },
447.  		{ "grey ooze",		PM_GRAY_OOZE },
448.  		{ "gray-elf",		PM_GREY_ELF },
449.  		{ "mindflayer",         PM_MIND_FLAYER },
450.  		{ "master mindflayer",  PM_MASTER_MIND_FLAYER },
451.  	    /* Hyphenated names */
452.  		{ "ki rin",		PM_KI_RIN },
453.  		{ "uruk hai",		PM_URUK_HAI },
454.  		{ "orc captain",	PM_ORC_CAPTAIN },
455.  		{ "woodland elf",	PM_WOODLAND_ELF },
456.  		{ "green elf",		PM_GREEN_ELF },
457.  		{ "grey elf",		PM_GREY_ELF },
458.  		{ "gray elf",		PM_GREY_ELF },
459.  		{ "elf lord",		PM_ELF_LORD },
460.  #if 0	/* OBSOLETE */
461.  		{ "high elf",		PM_HIGH_ELF },
462.  #endif
463.  		{ "olog hai",		PM_OLOG_HAI },
464.  		{ "arch lich",		PM_ARCH_LICH },
465.  	    /* Some irregular plurals */
466.  		{ "incubi",		PM_INCUBUS },
467.  		{ "succubi",		PM_SUCCUBUS },
468.  		{ "violet fungi",	PM_VIOLET_FUNGUS },
469.  		{ "homunculi",		PM_HOMUNCULUS },
470.  		{ "baluchitheria",	PM_BALUCHITHERIUM },
471.  		{ "lurkers above",	PM_LURKER_ABOVE },
472.  		{ "cavemen",		PM_CAVEMAN },
473.  		{ "cavewomen",		PM_CAVEWOMAN },
474.  #ifndef ZOUTHERN
475.  /*		{ "zruties",            PM_ZRUTY },*/
476.  #endif
477.  		{ "djinn",		PM_DJINNI },
478.  		{ "mumakil",		PM_MUMAK },
479.  		{ "erinyes",		PM_ERINYS },
480.  		{ "giant lice",         PM_GIANT_LOUSE },	/* RJ */
481.  	    /* falsely caught by -ves check above */
482.  		{ "master of thief",	PM_MASTER_OF_THIEVES },
483.  	    /* end of list */
484.  		{ 0, 0 }
485.  	};
486.  	register const struct alt_spl *namep;
487.  
488.  	for (namep = names; namep->name; namep++)
489.  	    if (!strncmpi(str, namep->name, (int)strlen(namep->name)))
490.  		return namep->pm_val;
491.      }
492.  
493.  	for (len = 0, i = LOW_PM; i < NUMMONS; i++) {
494.  	    register int m_i_len = strlen(mons[i].mname);
495.  	    if (m_i_len > len && !strncmpi(mons[i].mname, str, m_i_len)) {
496.  		if (m_i_len == slen) return i;	/* exact match */
497.  		else if (slen > m_i_len &&
498.  			(str[m_i_len] == ' ' ||
499.  			 !strcmpi(&str[m_i_len], "s") ||
500.  			 !strncmpi(&str[m_i_len], "s ", 2) ||
501.  			 !strcmpi(&str[m_i_len], "'") ||
502.  			 !strncmpi(&str[m_i_len], "' ", 2) ||
503.  			 !strcmpi(&str[m_i_len], "'s") ||
504.  			 !strncmpi(&str[m_i_len], "'s ", 3) ||
505.  			 !strcmpi(&str[m_i_len], "es") ||
506.  			 !strncmpi(&str[m_i_len], "es ", 3))) {
507.  		    mntmp = i;
508.  		    len = m_i_len;
509.  		}
510.  	    }
511.  	}
512.  	if (mntmp == NON_PM) mntmp = title_to_mon(str, (int *)0, (int *)0);
513.  	return mntmp;
514.  }
515.  
516.  #endif /* OVL1 */
517.  #ifdef OVL2
518.  
519.  /* returns 3 values (0=male, 1=female, 2=none) */
520.  int
521.  gender(mtmp)
522.  register struct monst *mtmp;
523.  {
524.  	if (is_neuter(mtmp->data)) return 2;
525.  	return mtmp->female;
526.  }
527.  
528.  /* Like gender(), but lower animals and such are still "it". */
529.  /* This is the one we want to use when printing messages. */
530.  int
531.  pronoun_gender(mtmp)
532.  register struct monst *mtmp;
533.  {
534.  	if (!mtmp->isshk && (is_neuter(mtmp->data) || !canspotmon(mtmp))) return 2;
535.  	return (humanoid(mtmp->data) || (mtmp->data->geno & G_UNIQ) ||
536.  		type_is_pname(mtmp->data)) ? (int)mtmp->female : 2;
537.  }
538.  
539.  #endif /* OVL2 */
540.  #ifdef OVLB
541.  
542.  /* used for nearby monsters when you go to another level */
543.  boolean
544.  levl_follower(mtmp)
545.  struct monst *mtmp;
546.  {
547.  	/* monsters with the Amulet--even pets--won't follow across levels */
548.  	if (mon_has_amulet(mtmp)) return FALSE;
549.  
550.  	/* some monsters will follow even while intending to flee from you */
551.  	if (mtmp->mtame || mtmp->iswiz || is_fshk(mtmp)) return TRUE;
552.  
553.  	/* stalking types follow, but won't when fleeing unless you hold
554.  	   the Amulet */
555.  	return (boolean)((mtmp->data->mflags2 & M2_STALK) &&
556.  				(!mtmp->mflee || u.uhave.amulet));
557.  }
558.  
559.  static const short grownups[][2] = {
560.  	{PM_LITTLE_DOG, PM_DOG}, {PM_DOG, PM_LARGE_DOG},
561.  	{PM_HELL_HOUND_PUP, PM_HELL_HOUND},
562.  	{PM_KITTEN, PM_HOUSECAT}, {PM_HOUSECAT, PM_LARGE_CAT},
563.  	{PM_KOBOLD, PM_LARGE_KOBOLD}, {PM_LARGE_KOBOLD, PM_KOBOLD_LORD},
564.  	{PM_GNOME, PM_GNOME_LORD}, {PM_GNOME_LORD, PM_GNOME_WARRIOR},
565.  	{PM_DWARF, PM_DWARF_LORD}, {PM_DWARF_LORD, PM_DWARF_KING},
566.  	{PM_MIND_FLAYER, PM_MASTER_MIND_FLAYER},
567.  	{PM_ORC, PM_ORC_CAPTAIN}, {PM_HILL_ORC, PM_ORC_CAPTAIN},
568.  	{PM_MORDOR_ORC, PM_ORC_CAPTAIN}, {PM_URUK_HAI, PM_ORC_CAPTAIN},
569.  	{PM_SEWER_RAT, PM_GIANT_RAT},
570.  	{PM_CAVE_SPIDER, PM_GIANT_SPIDER},
571.  	{PM_OGRE, PM_OGRE_LORD}, {PM_OGRE_LORD, PM_OGRE_KING},
572.  	{PM_ELF, PM_ELF_LORD}, {PM_WOODLAND_ELF, PM_ELF_LORD},
573.  	{PM_GREEN_ELF, PM_ELF_LORD}, {PM_GREY_ELF, PM_ELF_LORD},
574.  	{PM_ELF_LORD, PM_ELVENKING},
575.  	{PM_LICH, PM_DEMILICH}, {PM_DEMILICH, PM_MASTER_LICH},
576.  	{PM_MASTER_LICH, PM_ARCH_LICH},
577.  	{PM_VAMPIRE, PM_VAMPIRE_LORD}, {PM_VAMPIRE_LORD, PM_VAMPIRE_MAGE}, 
578.  	{PM_BAT, PM_GIANT_BAT},
579.  	{PM_CHICKATRICE, PM_COCKATRICE},
580.  	{PM_BABY_GRAY_DRAGON, PM_GRAY_DRAGON},
581.  	{PM_BABY_RED_DRAGON, PM_RED_DRAGON},
582.  	{PM_BABY_SILVER_DRAGON, PM_SILVER_DRAGON},
583.  	{PM_BABY_DEEP_DRAGON, PM_DEEP_DRAGON},
584.  	{PM_BABY_SHIMMERING_DRAGON, PM_SHIMMERING_DRAGON},
585.  	{PM_BABY_WHITE_DRAGON, PM_WHITE_DRAGON},
586.  	{PM_BABY_ORANGE_DRAGON, PM_ORANGE_DRAGON},
587.  	{PM_BABY_BLACK_DRAGON, PM_BLACK_DRAGON},
588.  	{PM_BABY_BLUE_DRAGON, PM_BLUE_DRAGON},
589.  	{PM_BABY_GREEN_DRAGON, PM_GREEN_DRAGON},
590.  	{PM_BABY_YELLOW_DRAGON, PM_YELLOW_DRAGON},
591.  	{PM_RED_NAGA_HATCHLING, PM_RED_NAGA},
592.  	{PM_BLACK_NAGA_HATCHLING, PM_BLACK_NAGA},
593.  	{PM_GOLDEN_NAGA_HATCHLING, PM_GOLDEN_NAGA},
594.  	{PM_GUARDIAN_NAGA_HATCHLING, PM_GUARDIAN_NAGA},
595.  	{PM_SMALL_MIMIC, PM_LARGE_MIMIC}, {PM_LARGE_MIMIC, PM_GIANT_MIMIC},
596.  	{PM_BABY_LONG_WORM, PM_LONG_WORM},
597.  	{PM_BABY_PURPLE_WORM, PM_PURPLE_WORM},
598.  	{PM_BABY_CROCODILE, PM_CROCODILE},
599.  	{PM_SOLDIER, PM_SERGEANT},
600.  	{PM_SERGEANT, PM_LIEUTENANT},
601.  	{PM_LIEUTENANT, PM_CAPTAIN},
602.  	{PM_WATCHMAN, PM_WATCH_CAPTAIN},
603.  	{PM_ALIGNED_PRIEST, PM_HIGH_PRIEST},
604.  	{PM_STUDENT, PM_ARCHEOLOGIST},
605.  	{PM_ATTENDANT, PM_HEALER},
606.  	{PM_PAGE, PM_KNIGHT},
607.  	{PM_ACOLYTE, PM_PRIEST},
608.  	{PM_APPRENTICE, PM_WIZARD},
609.  	{PM_MANES,PM_LEMURE},
610.  #ifdef KOPS
611.  	{PM_KEYSTONE_KOP, PM_KOP_SERGEANT},
612.  	{PM_KOP_SERGEANT, PM_KOP_LIEUTENANT},
613.  	{PM_KOP_LIEUTENANT, PM_KOP_KAPTAIN},
614.  #endif
615.  	/* WAC -- added killer coin piles */
616.  	{PM_PILE_OF_KILLER_COINS, PM_LARGE_PILE_OF_KILLER_COINS},
617.  	{PM_LARGE_PILE_OF_KILLER_COINS,PM_HUGE_PILE_OF_KILLER_COINS},
618.  	/* KMH -- added more sequences */
619.  	{PM_DINGO_PUPPY, PM_DINGO}, {PM_DINGO, PM_LARGE_DINGO},
620.  	{PM_PONY, PM_HORSE}, {PM_HORSE, PM_WARHORSE},
621.  	{PM_LARVA, PM_MAGGOT}, {PM_MAGGOT, PM_DUNG_WORM},
622.  	{PM_WINTER_WOLF_CUB, PM_WINTER_WOLF},
623.  	{PM_GIANT_TICK, PM_GIANT_FLEA}, {PM_GIANT_FLEA, PM_GIANT_LOUSE},	/* RJ */
624.  	/* DS -- growing up, Lethe style */
625.  	{PM_DEEP_ONE, PM_DEEPER_ONE}, {PM_DEEPER_ONE, PM_DEEPEST_ONE},
626.  	{PM_LAMB, PM_SHEEP}, 
627.  	{PM_SHOGGOTH, PM_GIANT_SHOGGOTH},
628.  	{PM_GNOLL, PM_GNOLL_WARRIOR}, {PM_GNOLL_WARRIOR, PM_GNOLL_CHIEFTAIN},
629.  	{PM_MIGO_DRONE, PM_MIGO_WARRIOR},
630.  
631.  	{NON_PM,NON_PM}
632.  };
633.  
634.  int
635.  little_to_big(montype)
636.  int montype;
637.  {
638.  #ifndef AIXPS2_BUG
639.  	register int i;
640.  
641.  	for (i = 0; grownups[i][0] >= LOW_PM; i++)
642.  		if(montype == grownups[i][0]) return grownups[i][1];
643.  	return montype;
644.  #else
645.  /* AIX PS/2 C-compiler 1.1.1 optimizer does not like the above for loop,
646.   * and causes segmentation faults at runtime.  (The problem does not
647.   * occur if -O is not used.)
648.   * lehtonen@cs.Helsinki.FI (Tapio Lehtonen) 28031990
649.   */
650.  	int i;
651.  	int monvalue;
652.  
653.  	monvalue = montype;
654.  	for (i = 0; grownups[i][0] >= LOW_PM; i++)
655.  		if(montype == grownups[i][0]) monvalue = grownups[i][1];
656.  
657.  	return monvalue;
658.  #endif
659.  }
660.  
661.  int
662.  big_to_little(montype)
663.  int montype;
664.  {
665.  	register int i;
666.  
667.  	for (i = 0; grownups[i][0] >= LOW_PM; i++)
668.  		if(montype == grownups[i][1]) return grownups[i][0];
669.  	return montype;
670.  }
671.  
672.  /*
673.   * Return the permonst ptr for the race of the monster.
674.   * Returns correct pointer for non-polymorphed and polymorphed
675.   * player.  It does not return a pointer to player role character.
676.   */
677.  const struct permonst *
678.  raceptr(mtmp)
679.  struct monst *mtmp;
680.  {
681.      if (mtmp == &youmonst && !Upolyd) return(&mons[urace.malenum]);
682.      else return(mtmp->data);
683.  }
684.  
685.  static const char *levitate[4]	= { "float", "Float", "wobble", "Wobble" };
686.  static const char *flys[4]	= { "fly", "Fly", "flutter", "Flutter" };
687.  static const char *flyl[4]	= { "fly", "Fly", "stagger", "Stagger" };
688.  static const char *slither[4]	= { "slither", "Slither", "falter", "Falter" };
689.  static const char *ooze[4]	= { "ooze", "Ooze", "tremble", "Tremble" };
690.  static const char *immobile[4]	= { "wiggle", "Wiggle", "pulsate", "Pulsate" };
691.  static const char *crawl[4]	= { "crawl", "Crawl", "falter", "Falter" };
692.  
693.  const char *
694.  locomotion(ptr, def)
695.  const struct permonst *ptr;
696.  const char *def;
697.  {
698.  	int capitalize = (*def == highc(*def));
699.  
700.  	return (
701.  		is_floater(ptr) ? levitate[capitalize] :
702.  		(is_flyer(ptr) && ptr->msize <= MZ_SMALL) ? flys[capitalize] :
703.  		(is_flyer(ptr) && ptr->msize > MZ_SMALL)  ? flyl[capitalize] :
704.  		slithy(ptr)     ? slither[capitalize] :
705.  		amorphous(ptr)  ? ooze[capitalize] :
706.  		!ptr->mmove	? immobile[capitalize] :
707.  		nolimbs(ptr)    ? crawl[capitalize] :
708.  		def
709.  	       );
710.  
711.  }
712.  
713.  const char *
714.  stagger(ptr, def)
715.  const struct permonst *ptr;
716.  const char *def;
717.  {
718.  	int capitalize = 2 + (*def == highc(*def));
719.  
720.  	return (
721.  		is_floater(ptr) ? levitate[capitalize] :
722.  		(is_flyer(ptr) && ptr->msize <= MZ_SMALL) ? flys[capitalize] :
723.  		(is_flyer(ptr) && ptr->msize > MZ_SMALL)  ? flyl[capitalize] :
724.  		slithy(ptr)     ? slither[capitalize] :
725.  		amorphous(ptr)  ? ooze[capitalize] :
726.  		!ptr->mmove	? immobile[capitalize] :
727.  		nolimbs(ptr)    ? crawl[capitalize] :
728.  		def
729.  	       );
730.  
731.  }
732.  
733.  /* return a phrase describing the effect of fire attack on a type of monster */
734.  const char *
735.  on_fire(mptr, mattk)
736.  struct permonst *mptr;
737.  struct attack *mattk;
738.  {
739.      const char *what;
740.  
741.      switch (monsndx(mptr)) {
742.      case PM_FLAMING_SPHERE:
743.      case PM_FIRE_VORTEX:
744.      case PM_FIRE_ELEMENTAL:
745.      case PM_SALAMANDER:
746.  	what = "already on fire";
747.  	break;
748.      case PM_WATER_ELEMENTAL:
749.      case PM_FOG_CLOUD:
750.      case PM_STEAM_VORTEX:
751.  	what = "boiling";
752.  	break;
753.      case PM_ICE_VORTEX:
754.      case PM_GLASS_GOLEM:
755.  	what = "melting";
756.  	break;
757.      case PM_STONE_GOLEM:
758.      case PM_CLAY_GOLEM:
759.      case PM_GOLD_GOLEM:
760.      case PM_AIR_ELEMENTAL:
761.      case PM_EARTH_ELEMENTAL:
762.      case PM_DUST_VORTEX:
763.      case PM_ENERGY_VORTEX:
764.  	what = "heating up";
765.  	break;
766.      default:
767.  	what = (mattk->aatyp == AT_HUGS) ? "being roasted" : "on fire";
768.  	break;
769.      }
770.      return what;
771.  }
772.  
773.  #endif /* OVLB */
774.  
775.  /*mondata.c*/

Also on Fandom

Random Wiki