Source:Mondata.c

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