Source:SLASH'EM 0.0.7E7F2/mondata.c

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.

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*/