src/mondata.c

   1 /* NetHack 3.6  mondata.c       $NHDT-Date: 1446604115 2015/11/04 02:28:35 $  $NHDT-Branch: master $:$NHDT-Revision: 1.58 $ */
   2 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   3 /* NetHack may be freely redistributed.  See license for details. */
   4
   5 /* JNetHack Copyright */
   6 /* (c) Issei Numata, Naoki Hamada, Shigehiro Miyashita, 1994-2000  */
   7 /* For 3.4-, Copyright (c) SHIRAKATA Kentaro, 2002-2016            */
   8 /* JNetHack may be freely redistributed.  See license for details. */
   9
  10 #include "hack.h"
  11
  12 /*      These routines provide basic data for any type of monster. */
  13
  14 /* set up an individual monster's base type (initial creation, shapechange) */
  15 void
  16 set_mon_data(mon, ptr, flag)
  17 struct monst *mon;
  18 struct permonst *ptr;
  19 int flag;
  20 {
  21     mon->data = ptr;
  22     if (flag == -1)
  23         return; /* "don't care" */
  24
  25     if (flag == 1)
  26         mon->mintrinsics |= (ptr->mresists & 0x00FF);
  27     else
  28         mon->mintrinsics = (ptr->mresists & 0x00FF);
  29     return;
  30 }
  31
  32 /* does monster-type have any attack for a specific type of damage? */
  33 struct attack *
  34 attacktype_fordmg(ptr, atyp, dtyp)
  35 struct permonst *ptr;
  36 int atyp, dtyp;
  37 {
  38     struct attack *a;
  39
  40     for (a = &ptr->mattk[0]; a < &ptr->mattk[NATTK]; a++)
  41         if (a->aatyp == atyp && (dtyp == AD_ANY || a->adtyp == dtyp))
  42             return a;
  43     return (struct attack *) 0;
  44 }
  45
  46 /* does monster-type have a particular type of attack */
  47 boolean
  48 attacktype(ptr, atyp)
  49 struct permonst *ptr;
  50 int atyp;
  51 {
  52     return attacktype_fordmg(ptr, atyp, AD_ANY) ? TRUE : FALSE;
  53 }
  54
  55 /* returns True if monster doesn't attack, False if it does */
  56 boolean
  57 noattacks(ptr)
  58 struct permonst *ptr;
  59 {
  60     int i;
  61     struct attack *mattk = ptr->mattk;
  62
  63     for (i = 0; i < NATTK; i++) {
  64         /* AT_BOOM "passive attack" (gas spore's explosion upon death)
  65            isn't an attack as far as our callers are concerned */
  66         if (mattk[i].aatyp == AT_BOOM)
  67             continue;
  68
  69         if (mattk[i].aatyp)
  70             return FALSE;
  71     }
  72     return TRUE;
  73 }
  74
  75 /* does monster-type transform into something else when petrified? */
  76 boolean
  77 poly_when_stoned(ptr)
  78 struct permonst *ptr;
  79 {
  80     /* non-stone golems turn into stone golems unless latter is genocided */
  81     return (boolean) (is_golem(ptr) && ptr != &mons[PM_STONE_GOLEM]
  82                       && !(mvitals[PM_STONE_GOLEM].mvflags & G_GENOD));
  83     /* allow G_EXTINCT */
  84 }
  85
  86 /* returns True if monster is drain-life resistant */
  87 boolean
  88 resists_drli(mon)
  89 struct monst *mon;
  90 {
  91     struct permonst *ptr = mon->data;
  92     struct obj *wep;
  93
  94     if (is_undead(ptr) || is_demon(ptr) || is_were(ptr)
  95         /* is_were() doesn't handle hero in human form */
  96         || (mon == &youmonst && u.ulycn >= LOW_PM)
  97         || ptr == &mons[PM_DEATH] || is_vampshifter(mon))
  98         return TRUE;
  99     wep = (mon == &youmonst) ? uwep : MON_WEP(mon);
 100     return (boolean) (wep && wep->oartifact && defends(AD_DRLI, wep));
 101 }
 102
 103 /* True if monster is magic-missile (actually, general magic) resistant */
 104 boolean
 105 resists_magm(mon)
 106 struct monst *mon;
 107 {
 108     struct permonst *ptr = mon->data;
 109     boolean is_you = (mon == &youmonst);
 110     long slotmask;
 111     struct obj *o;
 112
 113     /* as of 3.2.0:  gray dragons, Angels, Oracle, Yeenoghu */
 114     if (dmgtype(ptr, AD_MAGM) || ptr == &mons[PM_BABY_GRAY_DRAGON]
 115         || dmgtype(ptr, AD_RBRE)) /* Chromatic Dragon */
 116         return TRUE;
 117     /* check for magic resistance granted by wielded weapon */
 118     o = is_you ? uwep : MON_WEP(mon);
 119     if (o && o->oartifact && defends(AD_MAGM, o))
 120         return TRUE;
 121     /* check for magic resistance granted by worn or carried items */
 122     o = is_you ? invent : mon->minvent;
 123     slotmask = W_ARMOR | W_ACCESSORY;
 124     if (!is_you /* assumes monsters don't wield non-weapons */
 125         || (uwep && (uwep->oclass == WEAPON_CLASS || is_weptool(uwep))))
 126         slotmask |= W_WEP;
 127     if (is_you && u.twoweap)
 128         slotmask |= W_SWAPWEP;
 129     for (; o; o = o->nobj)
 130         if (((o->owornmask & slotmask) != 0L
 131              && objects[o->otyp].oc_oprop == ANTIMAGIC)
 132             || (o->oartifact && defends_when_carried(AD_MAGM, o)))
 133             return TRUE;
 134     return FALSE;
 135 }
 136
 137 /* True iff monster is resistant to light-induced blindness */
 138 boolean
 139 resists_blnd(mon)
 140 struct monst *mon;
 141 {
 142     struct permonst *ptr = mon->data;
 143     boolean is_you = (mon == &youmonst);
 144     long slotmask;
 145     struct obj *o;
 146
 147     if (is_you ? (Blind || Unaware)
 148                : (mon->mblinded || !mon->mcansee || !haseyes(ptr)
 149                   /* BUG: temporary sleep sets mfrozen, but since
 150                           paralysis does too, we can't check it */
 151                   || mon->msleeping))
 152         return TRUE;
 153     /* yellow light, Archon; !dust vortex, !cobra, !raven */
 154     if (dmgtype_fromattack(ptr, AD_BLND, AT_EXPL)
 155         || dmgtype_fromattack(ptr, AD_BLND, AT_GAZE))
 156         return TRUE;
 157     o = is_you ? uwep : MON_WEP(mon);
 158     if (o && o->oartifact && defends(AD_BLND, o))
 159         return TRUE;
 160     o = is_you ? invent : mon->minvent;
 161     slotmask = W_ARMOR | W_ACCESSORY;
 162     if (!is_you /* assumes monsters don't wield non-weapons */
 163         || (uwep && (uwep->oclass == WEAPON_CLASS || is_weptool(uwep))))
 164         slotmask |= W_WEP;
 165     if (is_you && u.twoweap)
 166         slotmask |= W_SWAPWEP;
 167     for (; o; o = o->nobj)
 168         if (((o->owornmask & slotmask) != 0L
 169              && objects[o->otyp].oc_oprop == BLINDED)
 170             || (o->oartifact && defends_when_carried(AD_BLND, o)))
 171             return TRUE;
 172     return FALSE;
 173 }
 174
 175 /* True iff monster can be blinded by the given attack;
 176    note: may return True when mdef is blind (e.g. new cream-pie attack) */
 177 boolean
 178 can_blnd(magr, mdef, aatyp, obj)
 179 struct monst *magr; /* NULL == no specific aggressor */
 180 struct monst *mdef;
 181 uchar aatyp;
 182 struct obj *obj; /* aatyp == AT_WEAP, AT_SPIT */
 183 {
 184     boolean is_you = (mdef == &youmonst);
 185     boolean check_visor = FALSE;
 186     struct obj *o;
 187     const char *s;
 188
 189     /* no eyes protect against all attacks for now */
 190     if (!haseyes(mdef->data))
 191         return FALSE;
 192
 193     switch (aatyp) {
 194     case AT_EXPL:
 195     case AT_BOOM:
 196     case AT_GAZE:
 197     case AT_MAGC:
 198     case AT_BREA: /* assumed to be lightning */
 199         /* light-based attacks may be cancelled or resisted */
 200         if (magr && magr->mcan)
 201             return FALSE;
 202         return !resists_blnd(mdef);
 203
 204     case AT_WEAP:
 205     case AT_SPIT:
 206     case AT_NONE:
 207         /* an object is used (thrown/spit/other) */
 208         if (obj && (obj->otyp == CREAM_PIE)) {
 209             if (is_you && Blindfolded)
 210                 return FALSE;
 211         } else if (obj && (obj->otyp == BLINDING_VENOM)) {
 212             /* all ublindf, including LENSES, protect, cream-pies too */
 213             if (is_you && (ublindf || u.ucreamed))
 214                 return FALSE;
 215             check_visor = TRUE;
 216         } else if (obj && (obj->otyp == POT_BLINDNESS)) {
 217             return TRUE; /* no defense */
 218         } else
 219             return FALSE; /* other objects cannot cause blindness yet */
 220         if ((magr == &youmonst) && u.uswallow)
 221             return FALSE; /* can't affect eyes while inside monster */
 222         break;
 223
 224     case AT_ENGL:
 225         if (is_you && (Blindfolded || Unaware || u.ucreamed))
 226             return FALSE;
 227         if (!is_you && mdef->msleeping)
 228             return FALSE;
 229         break;
 230
 231     case AT_CLAW:
 232         /* e.g. raven: all ublindf, including LENSES, protect */
 233         if (is_you && ublindf)
 234             return FALSE;
 235         if ((magr == &youmonst) && u.uswallow)
 236             return FALSE; /* can't affect eyes while inside monster */
 237         check_visor = TRUE;
 238         break;
 239
 240     case AT_TUCH:
 241     case AT_STNG:
 242         /* some physical, blind-inducing attacks can be cancelled */
 243         if (magr && magr->mcan)
 244             return FALSE;
 245         break;
 246
 247     default:
 248         break;
 249     }
 250
 251     /* check if wearing a visor (only checked if visor might help) */
 252     if (check_visor) {
 253         o = (mdef == &youmonst) ? invent : mdef->minvent;
 254         for (; o; o = o->nobj)
 255 #if 0 /*JP*/
 256             if ((o->owornmask & W_ARMH)
 257                 && (s = OBJ_DESCR(objects[o->otyp])) != (char *) 0
 258                 && !strcmp(s, "visored helmet"))
 259 #else
 260             if ((o->owornmask & W_ARMH)
 261                 && (s = OBJ_DESCR(objects[o->otyp])) != (char *) 0
 262                 && !strcmp(s, "\96Ê\96j\95t\82«\82Ì\8a\95"))
 263 #endif
 264                 return FALSE;
 265     }
 266
 267     return TRUE;
 268 }
 269
 270 /* returns True if monster can attack at range */
 271 boolean
 272 ranged_attk(ptr)
 273 struct permonst *ptr;
 274 {
 275     register int i, atyp;
 276     long atk_mask = (1L << AT_BREA) | (1L << AT_SPIT) | (1L << AT_GAZE);
 277
 278     /* was: (attacktype(ptr, AT_BREA) || attacktype(ptr, AT_WEAP)
 279      *       || attacktype(ptr, AT_SPIT) || attacktype(ptr, AT_GAZE)
 280      *       || attacktype(ptr, AT_MAGC));
 281      * but that's too slow -dlc
 282      */
 283     for (i = 0; i < NATTK; i++) {
 284         atyp = ptr->mattk[i].aatyp;
 285         if (atyp >= AT_WEAP)
 286             return TRUE;
 287         /* assert(atyp < 32); */
 288         if ((atk_mask & (1L << atyp)) != 0L)
 289             return TRUE;
 290     }
 291     return FALSE;
 292 }
 293
 294 /* True if specific monster is especially affected by silver weapons */
 295 boolean
 296 mon_hates_silver(mon)
 297 struct monst *mon;
 298 {
 299     return (boolean) (is_vampshifter(mon) || hates_silver(mon->data));
 300 }
 301
 302 /* True if monster-type is especially affected by silver weapons */
 303 boolean
 304 hates_silver(ptr)
 305 register struct permonst *ptr;
 306 {
 307     return (boolean) (is_were(ptr) || ptr->mlet == S_VAMPIRE || is_demon(ptr)
 308                       || ptr == &mons[PM_SHADE]
 309                       || (ptr->mlet == S_IMP && ptr != &mons[PM_TENGU]));
 310 }
 311
 312 /* True iff the type of monster pass through iron bars */
 313 boolean
 314 passes_bars(mptr)
 315 struct permonst *mptr;
 316 {
 317     return (boolean) (passes_walls(mptr) || amorphous(mptr) || unsolid(mptr)
 318                       || is_whirly(mptr) || verysmall(mptr)
 319                       || dmgtype(mptr, AD_CORR) || dmgtype(mptr, AD_RUST)
 320                       || (slithy(mptr) && !bigmonst(mptr)));
 321 }
 322
 323 /* returns True if monster can blow (whistle, etc) */
 324 boolean
 325 can_blow(mtmp)
 326 register struct monst *mtmp;
 327 {
 328     if ((is_silent(mtmp->data) || mtmp->data->msound == MS_BUZZ)
 329         && (breathless(mtmp->data) || verysmall(mtmp->data)
 330             || !has_head(mtmp->data) || mtmp->data->mlet == S_EEL))
 331         return FALSE;
 332     if ((mtmp == &youmonst) && Strangled)
 333         return FALSE;
 334     return TRUE;
 335 }
 336
 337 /* True if mon is vulnerable to strangulation */
 338 boolean
 339 can_be_strangled(mon)
 340 struct monst *mon;
 341 {
 342     struct obj *mamul;
 343     boolean nonbreathing, nobrainer;
 344
 345     /* For amulet of strangulation support:  here we're considering
 346        strangulation to be loss of blood flow to the brain due to
 347        constriction of the arteries in the neck, so all headless
 348        creatures are immune (no neck) as are mindless creatures
 349        who don't need to breathe (brain, if any, doesn't care).
 350        Mindless creatures who do need to breath are vulnerable, as
 351        are non-breathing creatures which have higher brain function. */
 352     if (!has_head(mon->data))
 353         return FALSE;
 354     if (mon == &youmonst) {
 355         /* hero can't be mindless but poly'ing into mindless form can
 356            confer strangulation protection */
 357         nobrainer = mindless(youmonst.data);
 358         nonbreathing = Breathless;
 359     } else {
 360         nobrainer = mindless(mon->data);
 361         /* monsters don't wear amulets of magical breathing,
 362            so second part doesn't achieve anything useful... */
 363         nonbreathing = (breathless(mon->data)
 364                         || ((mamul = which_armor(mon, W_AMUL)) != 0
 365                             && (mamul->otyp == AMULET_OF_MAGICAL_BREATHING)));
 366     }
 367     return (boolean) (!nobrainer || !nonbreathing);
 368 }
 369
 370 /* returns True if monster can track well */
 371 boolean
 372 can_track(ptr)
 373 register struct permonst *ptr;
 374 {
 375     if (uwep && uwep->oartifact == ART_EXCALIBUR)
 376         return TRUE;
 377     else
 378         return (boolean) haseyes(ptr);
 379 }
 380
 381 /* creature will slide out of armor */
 382 boolean
 383 sliparm(ptr)
 384 register struct permonst *ptr;
 385 {
 386     return (boolean) (is_whirly(ptr) || ptr->msize <= MZ_SMALL
 387                       || noncorporeal(ptr));
 388 }
 389
 390 /* creature will break out of armor */
 391 boolean
 392 breakarm(ptr)
 393 register struct permonst *ptr;
 394 {
 395     if (sliparm(ptr))
 396         return FALSE;
 397
 398     return (boolean) (bigmonst(ptr)
 399                       || (ptr->msize > MZ_SMALL && !humanoid(ptr))
 400                       /* special cases of humanoids that cannot wear suits */
 401                       || ptr == &mons[PM_MARILITH]
 402                       || ptr == &mons[PM_WINGED_GARGOYLE]);
 403 }
 404
 405 /* creature sticks other creatures it hits */
 406 boolean
 407 sticks(ptr)
 408 register struct permonst *ptr;
 409 {
 410     return (boolean) (dmgtype(ptr, AD_STCK) || dmgtype(ptr, AD_WRAP)
 411                       || attacktype(ptr, AT_HUGS));
 412 }
 413
 414 /* some monster-types can't vomit */
 415 boolean
 416 cantvomit(ptr)
 417 struct permonst *ptr;
 418 {
 419     /* rats and mice are incapable of vomiting;
 420        which other creatures have the same limitation? */
 421     if (ptr->mlet == S_RODENT && ptr != &mons[PM_ROCK_MOLE]
 422         && ptr != &mons[PM_WOODCHUCK])
 423         return TRUE;
 424     return FALSE;
 425 }
 426
 427 /* number of horns this type of monster has on its head */
 428 int
 429 num_horns(ptr)
 430 struct permonst *ptr;
 431 {
 432     switch (monsndx(ptr)) {
 433     case PM_HORNED_DEVIL: /* ? "more than one" */
 434     case PM_MINOTAUR:
 435     case PM_ASMODEUS:
 436     case PM_BALROG:
 437         return 2;
 438     case PM_WHITE_UNICORN:
 439     case PM_GRAY_UNICORN:
 440     case PM_BLACK_UNICORN:
 441     case PM_KI_RIN:
 442         return 1;
 443     default:
 444         break;
 445     }
 446     return 0;
 447 }
 448
 449 /* does monster-type deal out a particular type of damage from a particular
 450    type of attack? */
 451 struct attack *
 452 dmgtype_fromattack(ptr, dtyp, atyp)
 453 struct permonst *ptr;
 454 int dtyp, atyp;
 455 {
 456     struct attack *a;
 457
 458     for (a = &ptr->mattk[0]; a < &ptr->mattk[NATTK]; a++)
 459         if (a->adtyp == dtyp && (atyp == AT_ANY || a->aatyp == atyp))
 460             return a;
 461     return (struct attack *) 0;
 462 }
 463
 464 /* does monster-type deal out a particular type of damage from any attack */
 465 boolean
 466 dmgtype(ptr, dtyp)
 467 struct permonst *ptr;
 468 int dtyp;
 469 {
 470     return dmgtype_fromattack(ptr, dtyp, AT_ANY) ? TRUE : FALSE;
 471 }
 472
 473 /* returns the maximum damage a defender can do to the attacker via
 474    a passive defense */
 475 int
 476 max_passive_dmg(mdef, magr)
 477 register struct monst *mdef, *magr;
 478 {
 479     int i, dmg = 0, multi2 = 0;
 480     uchar adtyp;
 481
 482     /* each attack by magr can result in passive damage */
 483     for (i = 0; i < NATTK; i++)
 484         switch (magr->data->mattk[i].aatyp) {
 485         case AT_CLAW:
 486         case AT_BITE:
 487         case AT_KICK:
 488         case AT_BUTT:
 489         case AT_TUCH:
 490         case AT_STNG:
 491         case AT_HUGS:
 492         case AT_ENGL:
 493         case AT_TENT:
 494         case AT_WEAP:
 495             multi2++;
 496             break;
 497         default:
 498             break;
 499         }
 500
 501     for (i = 0; i < NATTK; i++)
 502         if (mdef->data->mattk[i].aatyp == AT_NONE
 503             || mdef->data->mattk[i].aatyp == AT_BOOM) {
 504             adtyp = mdef->data->mattk[i].adtyp;
 505             if ((adtyp == AD_ACID && !resists_acid(magr))
 506                 || (adtyp == AD_COLD && !resists_cold(magr))
 507                 || (adtyp == AD_FIRE && !resists_fire(magr))
 508                 || (adtyp == AD_ELEC && !resists_elec(magr))
 509                 || adtyp == AD_PHYS) {
 510                 dmg = mdef->data->mattk[i].damn;
 511                 if (!dmg)
 512                     dmg = mdef->data->mlevel + 1;
 513                 dmg *= mdef->data->mattk[i].damd;
 514             } else
 515                 dmg = 0;
 516
 517             return dmg * multi2;
 518         }
 519     return 0;
 520 }
 521
 522 /* determine whether two monster types are from the same species */
 523 boolean
 524 same_race(pm1, pm2)
 525 struct permonst *pm1, *pm2;
 526 {
 527     char let1 = pm1->mlet, let2 = pm2->mlet;
 528
 529     if (pm1 == pm2)
 530         return TRUE; /* exact match */
 531     /* player races have their own predicates */
 532     if (is_human(pm1))
 533         return is_human(pm2);
 534     if (is_elf(pm1))
 535         return is_elf(pm2);
 536     if (is_dwarf(pm1))
 537         return is_dwarf(pm2);
 538     if (is_gnome(pm1))
 539         return is_gnome(pm2);
 540     if (is_orc(pm1))
 541         return is_orc(pm2);
 542     /* other creatures are less precise */
 543     if (is_giant(pm1))
 544         return is_giant(pm2); /* open to quibbling here */
 545     if (is_golem(pm1))
 546         return is_golem(pm2); /* even moreso... */
 547     if (is_mind_flayer(pm1))
 548         return is_mind_flayer(pm2);
 549     if (let1 == S_KOBOLD || pm1 == &mons[PM_KOBOLD_ZOMBIE]
 550         || pm1 == &mons[PM_KOBOLD_MUMMY])
 551         return (let2 == S_KOBOLD || pm2 == &mons[PM_KOBOLD_ZOMBIE]
 552                 || pm2 == &mons[PM_KOBOLD_MUMMY]);
 553     if (let1 == S_OGRE)
 554         return (let2 == S_OGRE);
 555     if (let1 == S_NYMPH)
 556         return (let2 == S_NYMPH);
 557     if (let1 == S_CENTAUR)
 558         return (let2 == S_CENTAUR);
 559     if (is_unicorn(pm1))
 560         return is_unicorn(pm2);
 561     if (let1 == S_DRAGON)
 562         return (let2 == S_DRAGON);
 563     if (let1 == S_NAGA)
 564         return (let2 == S_NAGA);
 565     /* other critters get steadily messier */
 566     if (is_rider(pm1))
 567         return is_rider(pm2); /* debatable */
 568     if (is_minion(pm1))
 569         return is_minion(pm2); /* [needs work?] */
 570     /* tengu don't match imps (first test handled case of both being tengu) */
 571     if (pm1 == &mons[PM_TENGU] || pm2 == &mons[PM_TENGU])
 572         return FALSE;
 573     if (let1 == S_IMP)
 574         return (let2 == S_IMP);
 575     /* and minor demons (imps) don't match major demons */
 576     else if (let2 == S_IMP)
 577         return FALSE;
 578     if (is_demon(pm1))
 579         return is_demon(pm2);
 580     if (is_undead(pm1)) {
 581         if (let1 == S_ZOMBIE)
 582             return (let2 == S_ZOMBIE);
 583         if (let1 == S_MUMMY)
 584             return (let2 == S_MUMMY);
 585         if (let1 == S_VAMPIRE)
 586             return (let2 == S_VAMPIRE);
 587         if (let1 == S_LICH)
 588             return (let2 == S_LICH);
 589         if (let1 == S_WRAITH)
 590             return (let2 == S_WRAITH);
 591         if (let1 == S_GHOST)
 592             return (let2 == S_GHOST);
 593     } else if (is_undead(pm2))
 594         return FALSE;
 595
 596     /* check for monsters which grow into more mature forms */
 597     if (let1 == let2) {
 598         int m1 = monsndx(pm1), m2 = monsndx(pm2), prv, nxt;
 599
 600         /* we know m1 != m2 (very first check above); test all smaller
 601            forms of m1 against m2, then all larger ones; don't need to
 602            make the corresponding tests for variants of m2 against m1 */
 603         for (prv = m1, nxt = big_to_little(m1); nxt != prv;
 604              prv = nxt, nxt = big_to_little(nxt))
 605             if (nxt == m2)
 606                 return TRUE;
 607         for (prv = m1, nxt = little_to_big(m1); nxt != prv;
 608              prv = nxt, nxt = little_to_big(nxt))
 609             if (nxt == m2)
 610                 return TRUE;
 611     }
 612     /* not caught by little/big handling */
 613     if (pm1 == &mons[PM_GARGOYLE] || pm1 == &mons[PM_WINGED_GARGOYLE])
 614         return (pm2 == &mons[PM_GARGOYLE]
 615                 || pm2 == &mons[PM_WINGED_GARGOYLE]);
 616     if (pm1 == &mons[PM_KILLER_BEE] || pm1 == &mons[PM_QUEEN_BEE])
 617         return (pm2 == &mons[PM_KILLER_BEE] || pm2 == &mons[PM_QUEEN_BEE]);
 618
 619     if (is_longworm(pm1))
 620         return is_longworm(pm2); /* handles tail */
 621     /* [currently there's no reason to bother matching up
 622         assorted bugs and blobs with their closest variants] */
 623     /* didn't match */
 624     return FALSE;
 625 }
 626
 627 /* return an index into the mons array */
 628 int
 629 monsndx(ptr)
 630 struct permonst *ptr;
 631 {
 632     register int i;
 633
 634     i = (int) (ptr - &mons[0]);
 635     if (i < LOW_PM || i >= NUMMONS) {
 636         panic("monsndx - could not index monster (%s)",
 637               fmt_ptr((genericptr_t) ptr));
 638         return NON_PM; /* will not get here */
 639     }
 640     return i;
 641 }
 642
 643 /* for handling alternate spellings */
 644 struct alt_spl {
 645     const char *name;
 646     short pm_val;
 647 };
 648
 649 /* figure out what type of monster a user-supplied string is specifying */
 650 int
 651 name_to_mon(in_str)
 652 const char *in_str;
 653 {
 654     /* Be careful.  We must check the entire string in case it was
 655      * something such as "ettin zombie corpse".  The calling routine
 656      * doesn't know about the "corpse" until the monster name has
 657      * already been taken off the front, so we have to be able to
 658      * read the name with extraneous stuff such as "corpse" stuck on
 659      * the end.
 660      * This causes a problem for names which prefix other names such
 661      * as "ettin" on "ettin zombie".  In this case we want the _longest_
 662      * name which exists.
 663      * This also permits plurals created by adding suffixes such as 's'
 664      * or 'es'.  Other plurals must still be handled explicitly.
 665      */
 666     register int i;
 667     register int mntmp = NON_PM;
 668     register char *s, *str, *term;
 669     char buf[BUFSZ];
 670     int len, slen;
 671
 672     str = strcpy(buf, in_str);
 673
 674     if (!strncmp(str, "a ", 2))
 675         str += 2;
 676     else if (!strncmp(str, "an ", 3))
 677         str += 3;
 678     else if (!strncmp(str, "the ", 4))
 679         str += 4;
 680
 681     slen = strlen(str);
 682     term = str + slen;
 683
 684     if ((s = strstri(str, "vortices")) != 0)
 685         Strcpy(s + 4, "ex");
 686     /* be careful with "ies"; "priest", "zombies" */
 687     else if (slen > 3 && !strcmpi(term - 3, "ies")
 688              && (slen < 7 || strcmpi(term - 7, "zombies")))
 689         Strcpy(term - 3, "y");
 690     /* luckily no monster names end in fe or ve with ves plurals */
 691     else if (slen > 3 && !strcmpi(term - 3, "ves"))
 692         Strcpy(term - 3, "f");
 693
 694     slen = strlen(str); /* length possibly needs recomputing */
 695
 696     {
 697         static const struct alt_spl names[] = {
 698             /* Alternate spellings */
 699             { "grey dragon", PM_GRAY_DRAGON },
 700             { "baby grey dragon", PM_BABY_GRAY_DRAGON },
 701             { "grey unicorn", PM_GRAY_UNICORN },
 702             { "grey ooze", PM_GRAY_OOZE },
 703             { "gray-elf", PM_GREY_ELF },
 704             { "mindflayer", PM_MIND_FLAYER },
 705             { "master mindflayer", PM_MASTER_MIND_FLAYER },
 706             /* More alternates; priest and priestess are separate monster
 707                types but that isn't the case for {aligned,high} priests */
 708             { "aligned priestess", PM_ALIGNED_PRIEST },
 709             { "high priestess", PM_HIGH_PRIEST },
 710             /* Inappropriate singularization by -ves check above */
 711             { "master of thief", PM_MASTER_OF_THIEVES },
 712             /* Potential misspellings where we want to avoid falling back
 713                to the rank title prefix (input has been singularized) */
 714             { "master thief", PM_MASTER_OF_THIEVES },
 715             { "master of assassin", PM_MASTER_ASSASSIN },
 716             /* Outdated names */
 717             { "invisible stalker", PM_STALKER },
 718             { "high-elf", PM_ELVENKING }, /* PM_HIGH_ELF is obsolete */
 719             { "halfling", PM_HOBBIT },    /* potential guess for polyself */
 720             /* Hyphenated names */
 721             { "ki rin", PM_KI_RIN },
 722             { "uruk hai", PM_URUK_HAI },
 723             { "orc captain", PM_ORC_CAPTAIN },
 724             { "woodland elf", PM_WOODLAND_ELF },
 725             { "green elf", PM_GREEN_ELF },
 726             { "grey elf", PM_GREY_ELF },
 727             { "gray elf", PM_GREY_ELF },
 728             { "elf lord", PM_ELF_LORD },
 729             { "olog hai", PM_OLOG_HAI },
 730             { "arch lich", PM_ARCH_LICH },
 731             /* Some irregular plurals */
 732             { "incubi", PM_INCUBUS },
 733             { "succubi", PM_SUCCUBUS },
 734             { "violet fungi", PM_VIOLET_FUNGUS },
 735             { "homunculi", PM_HOMUNCULUS },
 736             { "baluchitheria", PM_BALUCHITHERIUM },
 737             { "lurkers above", PM_LURKER_ABOVE },
 738             { "cavemen", PM_CAVEMAN },
 739             { "cavewomen", PM_CAVEWOMAN },
 740             { "djinn", PM_DJINNI },
 741             { "mumakil", PM_MUMAK },
 742             { "erinyes", PM_ERINYS },
 743             /* end of list */
 744             { 0, NON_PM }
 745         };
 746         register const struct alt_spl *namep;
 747
 748         for (namep = names; namep->name; namep++)
 749             if (!strncmpi(str, namep->name, (int) strlen(namep->name)))
 750                 return namep->pm_val;
 751     }
 752
 753     for (len = 0, i = LOW_PM; i < NUMMONS; i++) {
 754         register int m_i_len = strlen(mons[i].mname);
 755
 756         if (m_i_len > len && !strncmpi(mons[i].mname, str, m_i_len)) {
 757             if (m_i_len == slen) {
 758                 return i; /* exact match */
 759             } else if (slen > m_i_len
 760 #if 0 /*JP*/
 761                        && (str[m_i_len] == ' '
 762                            || !strcmpi(&str[m_i_len], "s")
 763                            || !strncmpi(&str[m_i_len], "s ", 2)
 764                            || !strcmpi(&str[m_i_len], "'")
 765                            || !strncmpi(&str[m_i_len], "' ", 2)
 766                            || !strcmpi(&str[m_i_len], "'s")
 767                            || !strncmpi(&str[m_i_len], "'s ", 3)
 768                            || !strcmpi(&str[m_i_len], "es")
 769                            || !strncmpi(&str[m_i_len], "es ", 3))) {
 770 #else
 771                        && !strncmp(&str[m_i_len], "\82Ì", 2)) {
 772 #endif
 773                 mntmp = i;
 774                 len = m_i_len;
 775             }
 776         }
 777     }
 778     if (mntmp == NON_PM)
 779         mntmp = title_to_mon(str, (int *) 0, (int *) 0);
 780     return mntmp;
 781 }
 782
 783 /* monster class from user input; used for genocide and controlled polymorph;
 784    returns 0 rather than MAXMCLASSES if no match is found */
 785 int
 786 name_to_monclass(in_str, mndx_p)
 787 const char *in_str;
 788 int *mndx_p;
 789 {
 790     /* Single letters are matched against def_monsyms[].sym; words
 791        or phrases are first matched against def_monsyms[].explain
 792        to check class description; if not found there, then against
 793        mons[].mname to test individual monster types.  Input can be a
 794        substring of the full description or mname, but to be accepted,
 795        such partial matches must start at beginning of a word.  Some
 796        class descriptions include "foo or bar" and "foo or other foo"
 797        so we don't want to accept "or", "other", "or other" there. */
 798     static NEARDATA const char *const falsematch[] = {
 799         /* multiple-letter input which matches any of these gets rejected */
 800         "an", "the", "or", "other", "or other", 0
 801     };
 802     /* positive pm_val => specific monster; negative => class */
 803     static NEARDATA const struct alt_spl truematch[] = {
 804         /* "long worm" won't match "worm" class but would accidentally match
 805            "long worm tail" class before the comparison with monster types */
 806         { "long worm", PM_LONG_WORM },
 807         /* matches wrong--or at least suboptimal--class */
 808         { "demon", -S_DEMON }, /* hits "imp or minor demon" */
 809         /* matches specific monster (overly restrictive) */
 810         { "devil", -S_DEMON }, /* always "horned devil" */
 811         /* some plausible guesses which need help */
 812         { "bug", -S_XAN },  /* would match bugbear... */
 813         { "fish", -S_EEL }, /* wouldn't match anything */
 814         /* end of list */
 815         { 0, NON_PM }
 816     };
 817     const char *p, *x;
 818     int i;
 819
 820     if (mndx_p)
 821         *mndx_p = NON_PM; /* haven't [yet] matched a specific type */
 822
 823     if (!in_str || !in_str[0]) {
 824         /* empty input */
 825         return 0;
 826     } else if (!in_str[1]) {
 827         /* single character */
 828         i = def_char_to_monclass(*in_str);
 829         if (i == S_MIMIC_DEF) { /* ']' -> 'm' */
 830             i = S_MIMIC;
 831         } else if (i == S_WORM_TAIL) { /* '~' -> 'w' */
 832             i = S_WORM;
 833             if (mndx_p)
 834                 *mndx_p = PM_LONG_WORM;
 835         } else if (i == MAXMCLASSES) /* maybe 'I' */
 836             i = (*in_str == DEF_INVISIBLE) ? S_invisible : 0;
 837         return i;
 838     } else {
 839         /* multiple characters */
 840         in_str = makesingular(in_str);
 841         /* check for special cases */
 842         for (i = 0; falsematch[i]; i++)
 843             if (!strcmpi(in_str, falsematch[i]))
 844                 return 0;
 845         for (i = 0; truematch[i].name; i++)
 846             if (!strcmpi(in_str, truematch[i].name)) {
 847                 i = truematch[i].pm_val;
 848                 if (i < 0)
 849                     return -i; /* class */
 850                 if (mndx_p)
 851                     *mndx_p = i; /* monster */
 852                 return mons[i].mlet;
 853             }
 854         /* check monster class descriptions */
 855         for (i = 1; i < MAXMCLASSES; i++) {
 856             x = def_monsyms[i].explain;
 857             if ((p = strstri(x, in_str)) != 0 && (p == x || *(p - 1) == ' '))
 858                 return i;
 859         }
 860         /* check individual species names; not as thorough as mon_to_name()
 861            but our caller can call that directly if desired */
 862         for (i = LOW_PM; i < NUMMONS; i++) {
 863             x = mons[i].mname;
 864             if ((p = strstri(x, in_str)) != 0
 865                 && (p == x || *(p - 1) == ' ')) {
 866                 if (mndx_p)
 867                     *mndx_p = i;
 868                 return mons[i].mlet;
 869             }
 870         }
 871     }
 872     return 0;
 873 }
 874
 875 /* returns 3 values (0=male, 1=female, 2=none) */
 876 int
 877 gender(mtmp)
 878 register struct monst *mtmp;
 879 {
 880     if (is_neuter(mtmp->data))
 881         return 2;
 882     return mtmp->female;
 883 }
 884
 885 /* Like gender(), but lower animals and such are still "it".
 886    This is the one we want to use when printing messages. */
 887 int
 888 pronoun_gender(mtmp)
 889 register struct monst *mtmp;
 890 {
 891     if (is_neuter(mtmp->data) || !canspotmon(mtmp))
 892         return 2;
 893     return (humanoid(mtmp->data) || (mtmp->data->geno & G_UNIQ)
 894             || type_is_pname(mtmp->data)) ? (int) mtmp->female : 2;
 895 }
 896
 897 /* used for nearby monsters when you go to another level */
 898 boolean
 899 levl_follower(mtmp)
 900 struct monst *mtmp;
 901 {
 902     if (mtmp == u.usteed)
 903         return TRUE;
 904
 905     /* Wizard with Amulet won't bother trying to follow across levels */
 906     if (mtmp->iswiz && mon_has_amulet(mtmp))
 907         return FALSE;
 908     /* some monsters will follow even while intending to flee from you */
 909     if (mtmp->mtame || mtmp->iswiz || is_fshk(mtmp))
 910         return TRUE;
 911     /* stalking types follow, but won't when fleeing unless you hold
 912        the Amulet */
 913     return (boolean) ((mtmp->data->mflags2 & M2_STALK)
 914                       && (!mtmp->mflee || u.uhave.amulet));
 915 }
 916
 917 static const short grownups[][2] = {
 918     { PM_CHICKATRICE, PM_COCKATRICE },
 919     { PM_LITTLE_DOG, PM_DOG },
 920     { PM_DOG, PM_LARGE_DOG },
 921     { PM_HELL_HOUND_PUP, PM_HELL_HOUND },
 922     { PM_WINTER_WOLF_CUB, PM_WINTER_WOLF },
 923     { PM_KITTEN, PM_HOUSECAT },
 924     { PM_HOUSECAT, PM_LARGE_CAT },
 925     { PM_PONY, PM_HORSE },
 926     { PM_HORSE, PM_WARHORSE },
 927     { PM_KOBOLD, PM_LARGE_KOBOLD },
 928     { PM_LARGE_KOBOLD, PM_KOBOLD_LORD },
 929     { PM_GNOME, PM_GNOME_LORD },
 930     { PM_GNOME_LORD, PM_GNOME_KING },
 931     { PM_DWARF, PM_DWARF_LORD },
 932     { PM_DWARF_LORD, PM_DWARF_KING },
 933     { PM_MIND_FLAYER, PM_MASTER_MIND_FLAYER },
 934     { PM_ORC, PM_ORC_CAPTAIN },
 935     { PM_HILL_ORC, PM_ORC_CAPTAIN },
 936     { PM_MORDOR_ORC, PM_ORC_CAPTAIN },
 937     { PM_URUK_HAI, PM_ORC_CAPTAIN },
 938     { PM_SEWER_RAT, PM_GIANT_RAT },
 939     { PM_CAVE_SPIDER, PM_GIANT_SPIDER },
 940     { PM_OGRE, PM_OGRE_LORD },
 941     { PM_OGRE_LORD, PM_OGRE_KING },
 942     { PM_ELF, PM_ELF_LORD },
 943     { PM_WOODLAND_ELF, PM_ELF_LORD },
 944     { PM_GREEN_ELF, PM_ELF_LORD },
 945     { PM_GREY_ELF, PM_ELF_LORD },
 946     { PM_ELF_LORD, PM_ELVENKING },
 947     { PM_LICH, PM_DEMILICH },
 948     { PM_DEMILICH, PM_MASTER_LICH },
 949     { PM_MASTER_LICH, PM_ARCH_LICH },
 950     { PM_VAMPIRE, PM_VAMPIRE_LORD },
 951     { PM_BAT, PM_GIANT_BAT },
 952     { PM_BABY_GRAY_DRAGON, PM_GRAY_DRAGON },
 953     { PM_BABY_SILVER_DRAGON, PM_SILVER_DRAGON },
 954 #if 0 /* DEFERRED */
 955     {PM_BABY_SHIMMERING_DRAGON, PM_SHIMMERING_DRAGON},
 956 #endif
 957     { PM_BABY_RED_DRAGON, PM_RED_DRAGON },
 958     { PM_BABY_WHITE_DRAGON, PM_WHITE_DRAGON },
 959     { PM_BABY_ORANGE_DRAGON, PM_ORANGE_DRAGON },
 960     { PM_BABY_BLACK_DRAGON, PM_BLACK_DRAGON },
 961     { PM_BABY_BLUE_DRAGON, PM_BLUE_DRAGON },
 962     { PM_BABY_GREEN_DRAGON, PM_GREEN_DRAGON },
 963     { PM_BABY_YELLOW_DRAGON, PM_YELLOW_DRAGON },
 964     { PM_RED_NAGA_HATCHLING, PM_RED_NAGA },
 965     { PM_BLACK_NAGA_HATCHLING, PM_BLACK_NAGA },
 966     { PM_GOLDEN_NAGA_HATCHLING, PM_GOLDEN_NAGA },
 967     { PM_GUARDIAN_NAGA_HATCHLING, PM_GUARDIAN_NAGA },
 968     { PM_SMALL_MIMIC, PM_LARGE_MIMIC },
 969     { PM_LARGE_MIMIC, PM_GIANT_MIMIC },
 970     { PM_BABY_LONG_WORM, PM_LONG_WORM },
 971     { PM_BABY_PURPLE_WORM, PM_PURPLE_WORM },
 972     { PM_BABY_CROCODILE, PM_CROCODILE },
 973     { PM_SOLDIER, PM_SERGEANT },
 974     { PM_SERGEANT, PM_LIEUTENANT },
 975     { PM_LIEUTENANT, PM_CAPTAIN },
 976     { PM_WATCHMAN, PM_WATCH_CAPTAIN },
 977     { PM_ALIGNED_PRIEST, PM_HIGH_PRIEST },
 978     { PM_STUDENT, PM_ARCHEOLOGIST },
 979     { PM_ATTENDANT, PM_HEALER },
 980     { PM_PAGE, PM_KNIGHT },
 981     { PM_ACOLYTE, PM_PRIEST },
 982     { PM_APPRENTICE, PM_WIZARD },
 983     { PM_MANES, PM_LEMURE },
 984     { PM_KEYSTONE_KOP, PM_KOP_SERGEANT },
 985     { PM_KOP_SERGEANT, PM_KOP_LIEUTENANT },
 986     { PM_KOP_LIEUTENANT, PM_KOP_KAPTAIN },
 987     { NON_PM, NON_PM }
 988 };
 989
 990 int
 991 little_to_big(montype)
 992 int montype;
 993 {
 994     register int i;
 995
 996     for (i = 0; grownups[i][0] >= LOW_PM; i++)
 997         if (montype == grownups[i][0]) {
 998             montype = grownups[i][1];
 999             break;
1000         }
1001     return montype;
1002 }
1003
1004 int
1005 big_to_little(montype)
1006 int montype;
1007 {
1008     register int i;
1009
1010     for (i = 0; grownups[i][0] >= LOW_PM; i++)
1011         if (montype == grownups[i][1]) {
1012             montype = grownups[i][0];
1013             break;
1014         }
1015     return montype;
1016 }
1017
1018 /*
1019  * Return the permonst ptr for the race of the monster.
1020  * Returns correct pointer for non-polymorphed and polymorphed
1021  * player.  It does not return a pointer to player role character.
1022  */
1023 const struct permonst *
1024 raceptr(mtmp)
1025 struct monst *mtmp;
1026 {
1027     if (mtmp == &youmonst && !Upolyd)
1028         return &mons[urace.malenum];
1029     else
1030         return mtmp->data;
1031 }
1032
1033 /*JP
1034 static const char *levitate[4] = { "float", "Float", "wobble", "Wobble" };
1035 */
1036 static const char *levitate[4] = { "\95\82\82", "\95\82\82", "\82æ\82ë\82ß\82", "\82æ\82ë\82ß\82" };
1037 /*JP
1038 static const char *flys[4] = { "fly", "Fly", "flutter", "Flutter" };
1039 */
1040 static const char *flys[4] = { "\94ò\82Ô", "\94ò\82Ô", "\82¨\82Ì\82Ì\82", "\82¨\82Ì\82Ì\82" };
1041 /*JP
1042 static const char *flyl[4] = { "fly", "Fly", "stagger", "Stagger" };
1043 */
1044 static const char *flyl[4] = { "\94ò\82Ô", "\94ò\82Ô", "\82æ\82ë\82ß\82", "\82æ\82ë\82ß\82" };
1045 /*JP
1046 static const char *slither[4] = { "slither", "Slither", "falter", "Falter" };
1047 */
1048 static const char *slither[4] = { "\8a\8a\82é", "\8a\8a\82é", "\82½\82¶\82ë\82®", "\82½\82¶\82ë\82®" };
1049 /*JP
1050 static const char *ooze[4] = { "ooze", "Ooze", "tremble", "Tremble" };
1051 */
1052 static const char *ooze[4] = { "\82É\82¶\82Ý\8fo\82é", "\82É\82¶\82Ý\8fo\82é", "\90g\90k\82¢\82·\82é", "\90g\90k\82¢\82·\82é" };
1053 /*JP
1054 static const char *immobile[4] = { "wiggle", "Wiggle", "pulsate", "Pulsate" };
1055 */
1056 static const char *immobile[4] = { "\93®\82", "\93®\82", "\90k\82¦\82é", "\90k\82¦\82é" };
1057 /*JP
1058 static const char *crawl[4] = { "crawl", "Crawl", "falter", "Falter" };
1059 */
1060 static const char *crawl[4] = { "\82Í\82¢\82¸\82é", "\82Í\82¢\82¸\82é", "\82½\82¶\82ë\82®", "\82½\82¶\82ë\82®" };
1061
1062 const char *
1063 locomotion(ptr, def)
1064 const struct permonst *ptr;
1065 const char *def;
1066 {
1067     int capitalize = (*def == highc(*def));
1068
1069     return (is_floater(ptr) ? levitate[capitalize]
1070             : (is_flyer(ptr) && ptr->msize <= MZ_SMALL) ? flys[capitalize]
1071               : (is_flyer(ptr) && ptr->msize > MZ_SMALL) ? flyl[capitalize]
1072                 : slithy(ptr) ? slither[capitalize]
1073                   : amorphous(ptr) ? ooze[capitalize]
1074                     : !ptr->mmove ? immobile[capitalize]
1075                       : nolimbs(ptr) ? crawl[capitalize]
1076                         : def);
1077 }
1078
1079 /*JP:
1080  * \81u\82æ\82ë\82ß\82\81v\82ð\89ö\95¨\82Ì\8eí\97Þ\82É\82æ\82Á\82Ä\95Ï\82¦\82é\81B
1081  * \8e©\95ª\82É\91Î\82µ\82Ä\8eg\82¤\8fê\8d\87\82É\82Í\8aù\82É\81u\82\82ç\82\82ç\82·\82é\81v\82ª\8eg\82í\82ê\82Ä\82¢\82é\82Ì\82Å\81A
1082  * \95Ï\89»\82µ\82Ä\82¢\82Ä\82à\82»\82Ì\82Ü\82Ü\82É\82·\82é\81B
1083  * \91\8a\8eè\82É\91Î\82µ\82Ä\8eg\82¤\8fê\8d\87\82Í\81u\82\82ç\82\82ç\82·\82é\81v\82Í\95s\8e©\91R\82È\82Ì\82Å\82±\82ê\82ð\8eg\82¤\81B
1084  */
1085 const char *
1086 stagger(ptr, def)
1087 const struct permonst *ptr;
1088 const char *def;
1089 {
1090     int capitalize = 2 + (*def == highc(*def));
1091
1092     return (is_floater(ptr) ? levitate[capitalize]
1093             : (is_flyer(ptr) && ptr->msize <= MZ_SMALL) ? flys[capitalize]
1094               : (is_flyer(ptr) && ptr->msize > MZ_SMALL) ? flyl[capitalize]
1095                 : slithy(ptr) ? slither[capitalize]
1096                   : amorphous(ptr) ? ooze[capitalize]
1097                     : !ptr->mmove ? immobile[capitalize]
1098                       : nolimbs(ptr) ? crawl[capitalize]
1099                         : def);
1100 }
1101 #if 1 /*JP*/
1102 static const char *levitate2 = "\95\82\82«\8fo\82½";
1103 static const char *fly2 = "\94ò\82Ñ\8fo\82½";
1104 static const char *slither2 = "\8a\8a\82è\8fo\82½";
1105 static const char *ooze2 = "\82É\82¶\82Ý\8fo\82½";
1106 static const char *crawl2 = "\82Í\82¢\82¸\82è\8fo\82½";
1107
1108 const char *
1109 jumpedthrough(ptr, def)
1110 const struct permonst *ptr;
1111 const char *def;
1112 {
1113         return (
1114             is_floater(ptr) ? levitate2 :
1115             is_flyer(ptr)   ? fly2 :
1116             slithy(ptr)     ? slither2 :
1117             amorphous(ptr)  ? ooze2 :
1118             nolimbs(ptr)    ? crawl2 :
1119             def
1120             );
1121 }
1122 #endif
1123
1124 /* return phrase describing the effect of fire attack on a type of monster */
1125 const char *
1126 on_fire(mptr, mattk)
1127 struct permonst *mptr;
1128 struct attack *mattk;
1129 {
1130     const char *what;
1131
1132     switch (monsndx(mptr)) {
1133     case PM_FLAMING_SPHERE:
1134     case PM_FIRE_VORTEX:
1135     case PM_FIRE_ELEMENTAL:
1136     case PM_SALAMANDER:
1137 /*JP
1138         what = "already on fire";
1139 */
1140         what = "\82·\82Å\82É\89\8a\82É\82Â\82Â\82Ü\82ê\82Ä\82¢\82é";
1141         break;
1142     case PM_WATER_ELEMENTAL:
1143     case PM_FOG_CLOUD:
1144     case PM_STEAM_VORTEX:
1145 /*JP
1146         what = "boiling";
1147 */
1148         what = "\95¦\93«\82µ\82½";
1149         break;
1150     case PM_ICE_VORTEX:
1151     case PM_GLASS_GOLEM:
1152 /*JP
1153         what = "melting";
1154 */
1155         what = "\97n\82¯\82½";
1156         break;
1157     case PM_STONE_GOLEM:
1158     case PM_CLAY_GOLEM:
1159     case PM_GOLD_GOLEM:
1160     case PM_AIR_ELEMENTAL:
1161     case PM_EARTH_ELEMENTAL:
1162     case PM_DUST_VORTEX:
1163     case PM_ENERGY_VORTEX:
1164 /*JP
1165         what = "heating up";
1166 */
1167         what = "\94M\82\82È\82Á\82½";
1168         break;
1169     default:
1170 /*JP
1171         what = (mattk->aatyp == AT_HUGS) ? "being roasted" : "on fire";
1172 */
1173         what = (mattk->aatyp == AT_HUGS) ? "\8aÛ\8fÄ\82¯\82É\82È\82Á\82½" : "\89Î\82¾\82é\82Ü\82É\82È\82Á\82½";
1174         break;
1175     }
1176     return what;
1177 }
1178
1179 /*
1180  * Returns:
1181  *      True if monster is presumed to have a sense of smell.
1182  *      False if monster definitely does not have a sense of smell.
1183  *
1184  * Do not base this on presence of a head or nose, since many
1185  * creatures sense smells other ways (feelers, forked-tongues, etc.)
1186  * We're assuming all insects can smell at a distance too.
1187  */
1188 boolean
1189 olfaction(mdat)
1190 struct permonst *mdat;
1191 {
1192     if (is_golem(mdat)
1193         || mdat->mlet == S_EYE /* spheres  */
1194         || mdat->mlet == S_JELLY || mdat->mlet == S_PUDDING
1195         || mdat->mlet == S_BLOB || mdat->mlet == S_VORTEX
1196         || mdat->mlet == S_ELEMENTAL
1197         || mdat->mlet == S_FUNGUS /* mushrooms and fungi */
1198         || mdat->mlet == S_LIGHT)
1199         return FALSE;
1200     return TRUE;
1201 }
1202
1203 /*mondata.c*/