src/mondata.c

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