src/monster2.c

   1 /* File: monster2.c */
   2
   3 /*
   4  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   5  *
   6  * This software may be copied and distributed for educational, research,
   7  * and not for profit purposes provided that this copyright and statement
   8  * are included in all such copies.  Other copyrights may also apply.
   9  */
  10
  11 /* Purpose: misc code for monsters */
  12
  13 #include "angband.h"
  14
  15 #define HORDE_NOGOOD 0x01
  16 #define HORDE_NOEVIL 0x02
  17
  18 cptr horror_desc[MAX_SAN_HORROR] =
  19 {
  20 #ifdef JP
  21         "´÷¤Þ¤ï¤·¤¤",
  22         "ÄìÃÎ¤ì¤Ì",
  23         "¤¾¤Ã¤È¤¹¤ë",
  24         "ÇËÌÇÅª¤Ê",
  25         "ËÁÆÂÅª¤Ê",
  26
  27         "¤¤¤ä¤Ê",
  28         "¶²¤í¤·¤¤",
  29         "ÉÔ·é¤Ê",
  30         "ÍÆ¼Ï¤Î¤Ê¤¤",
  31         "¤ª¤¾¤Þ¤·¤¤",
  32
  33         "ÃÏ¹ö¤Î",
  34         "¿È¤ÎÌÓ¤â¤è¤À¤Ä",
  35         "ÃÏ¹ö¤Î",
  36         "´÷¤Þ¤ï¤·¤¤",
  37         "°Ì´¤Î¤è¤¦¤Ê",
  38
  39         "·ù°¤ò´¶¤¸¤ë",
  40         "È³Åö¤¿¤ê¤Ê",
  41         "¶²¤¤",
  42         "ÉÔ¾ô¤Ê",
  43         "¸À¤¦¤â¤ª¤¾¤Þ¤·¤¤",
  44 #else
  45         "abominable",
  46         "abysmal",
  47         "appalling",
  48         "baleful",
  49         "blasphemous",
  50
  51         "disgusting",
  52         "dreadful",
  53         "filthy",
  54         "grisly",
  55         "hideous",
  56
  57         "hellish",
  58         "horrible",
  59         "infernal",
  60         "loathsome",
  61         "nightmarish",
  62
  63         "repulsive",
  64         "sacrilegious",
  65         "terrible",
  66         "unclean",
  67         "unspeakable",
  68 #endif
  69
  70 };
  71
  72 cptr funny_desc[MAX_SAN_FUNNY] =
  73 {
  74 #ifdef JP
  75         "´ÖÈ´¤±¤Ê",
  76         "³ê·Î¤Ê",
  77         "¤Ð¤«¤é¤·¤¤",
  78         "ÌµÌ£´¥Áç¤Ê",
  79         "ÇÏ¼¯¤²¤¿",
  80
  81         "¾Ð¤¨¤ë",
  82         "¤Ð¤«¤Ð¤«¤·¤¤",
  83         "¤Ö¤Ã¤È¤ó¤À",
  84         "¤¤¤«¤·¤¿",
  85         "¥Ý¥¹¥È¥â¥À¥ó¤Ê",
  86
  87         "¥Õ¥¡¥ó¥¿¥¹¥Æ¥£¥Ã¥¯¤Ê",
  88         "¥À¥À¥¤¥º¥àÅª¤Ê",
  89         "¥¥å¥Ó¥º¥àÅª¤Ê",
  90         "±§ÃèÅª¤Ê",
  91         "Âî±Û¤·¤¿",
  92
  93         "Íý²òÉÔÇ½¤Ê",
  94         "¤â¤Î¤¹¤´¤¤",
  95         "¶Ã¤¯¤Ù¤",
  96         "¿®¤¸¤é¤ì¤Ê¤¤",
  97         "¥«¥ª¥Æ¥£¥Ã¥¯¤Ê",
  98
  99         "ÌîÀÅª¤Ê",
 100         "Èó¾ï¼±¤Ê",
 101 #else
 102         "silly",
 103         "hilarious",
 104         "absurd",
 105         "insipid",
 106         "ridiculous",
 107
 108         "laughable",
 109         "ludicrous",
 110         "far-out",
 111         "groovy",
 112         "postmodern",
 113
 114         "fantastic",
 115         "dadaistic",
 116         "cubistic",
 117         "cosmic",
 118         "awesome",
 119
 120         "incomprehensible",
 121         "fabulous",
 122         "amazing",
 123         "incredible",
 124         "chaotic",
 125
 126         "wild",
 127         "preposterous",
 128 #endif
 129
 130 };
 131
 132 cptr funny_comments[MAX_SAN_COMMENT] =
 133 {
 134 #ifdef JP
 135   /* nuke me */
 136         "ºÇ¹â¤À¤¼¡ª",
 137         "¤¦¤Ò¤ç¡¼¡ª",
 138         "¤¤¤«¤¹¤¼¡ª",
 139         "¤¹¤ó¤Ð¤é¤·¤¤¡ª",
 140         "¤Ö¤Ã¤È¤Ó¡¼¡ª"
 141 #else
 142         "Wow, cosmic, man!",
 143         "Rad!",
 144         "Groovy!",
 145         "Cool!",
 146         "Far out!"
 147 #endif
 148
 149 };
 150
 151
 152 /*
 153  * Set the target of counter attack
 154  */
 155 void set_target(monster_type *m_ptr, int y, int x)
 156 {
 157         m_ptr->target_y = y;
 158         m_ptr->target_x = x;
 159 }
 160
 161
 162 /*
 163  * Reset the target of counter attack
 164  */
 165 void reset_target(monster_type *m_ptr)
 166 {
 167         set_target(m_ptr, 0, 0);
 168 }
 169
 170
 171 /*
 172  *  Extract monster race pointer of a monster's true form
 173  */
 174 monster_race *real_r_ptr(monster_type *m_ptr)
 175 {
 176         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 177
 178         /* Extract real race */
 179         if (m_ptr->mflag2 & MFLAG2_CHAMELEON)
 180         {
 181                 if (r_ptr->flags1 & RF1_UNIQUE)
 182                         return &r_info[MON_CHAMELEON_K];
 183                 else
 184                         return &r_info[MON_CHAMELEON];
 185         }
 186         else
 187         {
 188                 return r_ptr;
 189         }
 190 }
 191
 192
 193 /*
 194  * Delete a monster by index.
 195  *
 196  * When a monster is deleted, all of its objects are deleted.
 197  */
 198 void delete_monster_idx(int i)
 199 {
 200         int x, y;
 201
 202         monster_type *m_ptr = &m_list[i];
 203
 204         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 205
 206         s16b this_o_idx, next_o_idx = 0;
 207
 208
 209         /* Get location */
 210         y = m_ptr->fy;
 211         x = m_ptr->fx;
 212
 213
 214         /* Hack -- Reduce the racial counter */
 215         real_r_ptr(m_ptr)->cur_num--;
 216
 217         /* Hack -- count the number of "reproducers" */
 218         if (r_ptr->flags2 & (RF2_MULTIPLY)) num_repro--;
 219
 220
 221         /* Hack -- remove target monster */
 222         if (i == target_who) target_who = 0;
 223
 224         /* Hack -- remove tracked monster */
 225         if (i == p_ptr->health_who) health_track(0);
 226
 227         if (pet_t_m_idx == i ) pet_t_m_idx = 0;
 228         if (riding_t_m_idx == i) riding_t_m_idx = 0;
 229         if (p_ptr->riding == i) p_ptr->riding = 0;
 230
 231         /* Monster is gone */
 232         cave[y][x].m_idx = 0;
 233
 234
 235         /* Delete objects */
 236         for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
 237         {
 238                 object_type *o_ptr;
 239
 240                 /* Acquire object */
 241                 o_ptr = &o_list[this_o_idx];
 242
 243                 /* Acquire next object */
 244                 next_o_idx = o_ptr->next_o_idx;
 245
 246                 /*
 247                  * o_ptr->held_m_idx is needed in delete_object_idx()
 248                  * to prevent calling lite_spot()
 249                  */
 250
 251                 /* Delete the object */
 252                 delete_object_idx(this_o_idx);
 253         }
 254
 255
 256         /* Wipe the Monster */
 257         (void)WIPE(m_ptr, monster_type);
 258
 259         /* Count monsters */
 260         m_cnt--;
 261
 262         /* Visual update */
 263         lite_spot(y, x);
 264
 265         /* Update some things */
 266         if (r_ptr->flags7 & (RF7_LITE_MASK | RF7_DARK_MASK))
 267                 p_ptr->update |= (PU_MON_LITE);
 268 }
 269
 270
 271 /*
 272  * Delete the monster, if any, at a given location
 273  */
 274 void delete_monster(int y, int x)
 275 {
 276         cave_type *c_ptr;
 277
 278         /* Paranoia */
 279         if (!in_bounds(y, x)) return;
 280
 281         /* Check the grid */
 282         c_ptr = &cave[y][x];
 283
 284         /* Delete the monster (if any) */
 285         if (c_ptr->m_idx) delete_monster_idx(c_ptr->m_idx);
 286 }
 287
 288
 289 /*
 290  * Move an object from index i1 to index i2 in the object list
 291  */
 292 static void compact_monsters_aux(int i1, int i2)
 293 {
 294         int y, x, i;
 295
 296         cave_type *c_ptr;
 297
 298         monster_type *m_ptr;
 299
 300         s16b this_o_idx, next_o_idx = 0;
 301
 302
 303         /* Do nothing */
 304         if (i1 == i2) return;
 305
 306
 307         /* Old monster */
 308         m_ptr = &m_list[i1];
 309
 310         /* Location */
 311         y = m_ptr->fy;
 312         x = m_ptr->fx;
 313
 314         /* Cave grid */
 315         c_ptr = &cave[y][x];
 316
 317         /* Update the cave */
 318         c_ptr->m_idx = i2;
 319
 320         /* Repair objects being carried by monster */
 321         for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
 322         {
 323                 object_type *o_ptr;
 324
 325                 /* Acquire object */
 326                 o_ptr = &o_list[this_o_idx];
 327
 328                 /* Acquire next object */
 329                 next_o_idx = o_ptr->next_o_idx;
 330
 331                 /* Reset monster pointer */
 332                 o_ptr->held_m_idx = i2;
 333         }
 334
 335         /* Hack -- Update the target */
 336         if (target_who == i1) target_who = i2;
 337
 338         /* Hack -- Update the target */
 339         if (pet_t_m_idx == i1) pet_t_m_idx = i2;
 340         if (riding_t_m_idx == i1) riding_t_m_idx = i2;
 341
 342         /* Hack -- Update the riding */
 343         if (p_ptr->riding == i1) p_ptr->riding = i2;
 344
 345         /* Hack -- Update the health bar */
 346         if (p_ptr->health_who == i1) health_track(i2);
 347
 348         /* Hack -- Update parent index */
 349         if (is_pet(m_ptr))
 350         {
 351                 for (i = 1; i < m_max; i++)
 352                 {
 353                         monster_type *m2_ptr = &m_list[i];
 354
 355                         if (m2_ptr->parent_m_idx == i1)
 356                                 m2_ptr->parent_m_idx = i2;
 357                 }
 358         }
 359
 360         /* Structure copy */
 361         COPY(&m_list[i2], &m_list[i1], monster_type);
 362
 363         /* Wipe the hole */
 364         (void)WIPE(&m_list[i1], monster_type);
 365
 366 }
 367
 368
 369 /*
 370  * Compact and Reorder the monster list
 371  *
 372  * This function can be very dangerous, use with caution!
 373  *
 374  * When actually "compacting" monsters, we base the saving throw
 375  * on a combination of monster level, distance from player, and
 376  * current "desperation".
 377  *
 378  * After "compacting" (if needed), we "reorder" the monsters into a more
 379  * compact order, and we reset the allocation info, and the "live" array.
 380  */
 381 void compact_monsters(int size)
 382 {
 383         int             i, num, cnt;
 384         int             cur_lev, cur_dis, chance;
 385
 386         /* Message (only if compacting) */
 387 #ifdef JP
 388         if (size) msg_print("¥â¥ó¥¹¥¿¡¼¾ðÊó¤ò°µ½Ì¤·¤Æ¤¤¤Þ¤¹...");
 389 #else
 390         if (size) msg_print("Compacting monsters...");
 391 #endif
 392
 393
 394         /* Compact at least 'size' objects */
 395         for (num = 0, cnt = 1; num < size; cnt++)
 396         {
 397                 /* Get more vicious each iteration */
 398                 cur_lev = 5 * cnt;
 399
 400                 /* Get closer each iteration */
 401                 cur_dis = 5 * (20 - cnt);
 402
 403                 /* Check all the monsters */
 404                 for (i = 1; i < m_max; i++)
 405                 {
 406                         monster_type *m_ptr = &m_list[i];
 407
 408                         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 409
 410                         /* Paranoia -- skip "dead" monsters */
 411                         if (!m_ptr->r_idx) continue;
 412
 413                         /* Hack -- High level monsters start out "immune" */
 414                         if (r_ptr->level > cur_lev) continue;
 415
 416                         if (i == p_ptr->riding) continue;
 417
 418                         /* Ignore nearby monsters */
 419                         if ((cur_dis > 0) && (m_ptr->cdis < cur_dis)) continue;
 420
 421                         /* Saving throw chance */
 422                         chance = 90;
 423
 424                         /* Only compact "Quest" Monsters in emergencies */
 425                         if ((r_ptr->flags1 & (RF1_QUESTOR)) && (cnt < 1000)) chance = 100;
 426
 427                         /* Try not to compact Unique Monsters */
 428                         if (r_ptr->flags1 & (RF1_UNIQUE)) chance = 100;
 429
 430                         /* All monsters get a saving throw */
 431                         if (randint0(100) < chance) continue;
 432
 433                         /* Delete the monster */
 434                         delete_monster_idx(i);
 435
 436                         /* Count the monster */
 437                         num++;
 438                 }
 439         }
 440
 441
 442         /* Excise dead monsters (backwards!) */
 443         for (i = m_max - 1; i >= 1; i--)
 444         {
 445                 /* Get the i'th monster */
 446                 monster_type *m_ptr = &m_list[i];
 447
 448                 /* Skip real monsters */
 449                 if (m_ptr->r_idx) continue;
 450
 451                 /* Move last monster into open hole */
 452                 compact_monsters_aux(m_max - 1, i);
 453
 454                 /* Compress "m_max" */
 455                 m_max--;
 456         }
 457 }
 458
 459
 460 /*
 461  * Delete/Remove all the monsters when the player leaves the level
 462  *
 463  * This is an efficient method of simulating multiple calls to the
 464  * "delete_monster()" function, with no visual effects.
 465  */
 466 void wipe_m_list(void)
 467 {
 468         int i;
 469
 470         /* Hack -- if Banor or Lupart dies, stay another dead */
 471         if (!r_info[MON_BANORLUPART].max_num)
 472         {
 473                 if (r_info[MON_BANOR].max_num)
 474                 {
 475                         r_info[MON_BANOR].max_num = 0;
 476                         r_info[MON_BANOR].r_pkills++;
 477                         if (r_info[MON_BANOR].r_tkills < MAX_SHORT) r_info[MON_BANOR].r_tkills++;
 478                 }
 479                 if (r_info[MON_LUPART].max_num)
 480                 {
 481                         r_info[MON_LUPART].max_num = 0;
 482                         r_info[MON_LUPART].r_pkills++;
 483                         if (r_info[MON_LUPART].r_tkills < MAX_SHORT) r_info[MON_LUPART].r_tkills++;
 484                 }
 485         }
 486
 487         /* Delete all the monsters */
 488         for (i = m_max - 1; i >= 1; i--)
 489         {
 490                 monster_type *m_ptr = &m_list[i];
 491
 492                 /* Skip dead monsters */
 493                 if (!m_ptr->r_idx) continue;
 494
 495                 /* Monster is gone */
 496                 cave[m_ptr->fy][m_ptr->fx].m_idx = 0;
 497
 498                 /* Wipe the Monster */
 499                 (void)WIPE(m_ptr, monster_type);
 500
 501         }
 502
 503         /*
 504          * Wiping racial counters of all monsters and incrementing of racial
 505          * counters of monsters in party_mon[] is required to prevent multiple
 506          * generation of unique monster who is the minion of player.
 507          */
 508
 509         /* Hack -- Wipe the racial counter of all monster races */
 510         for (i = 1; i < max_r_idx; i++) r_info[i].cur_num = 0;
 511
 512         /* Reset "m_max" */
 513         m_max = 1;
 514
 515         /* Reset "m_cnt" */
 516         m_cnt = 0;
 517
 518         /* Hack -- reset "reproducer" count */
 519         num_repro = 0;
 520
 521         /* Hack -- no more target */
 522         target_who = 0;
 523         pet_t_m_idx = 0;
 524         riding_t_m_idx = 0;
 525
 526         /* Hack -- no more tracking */
 527         health_track(0);
 528 }
 529
 530
 531 /*
 532  * Acquires and returns the index of a "free" monster.
 533  *
 534  * This routine should almost never fail, but it *can* happen.
 535  */
 536 s16b m_pop(void)
 537 {
 538         int i;
 539
 540
 541         /* Normal allocation */
 542         if (m_max < max_m_idx)
 543         {
 544                 /* Access the next hole */
 545                 i = m_max;
 546
 547                 /* Expand the array */
 548                 m_max++;
 549
 550                 /* Count monsters */
 551                 m_cnt++;
 552
 553                 /* Return the index */
 554                 return (i);
 555         }
 556
 557
 558         /* Recycle dead monsters */
 559         for (i = 1; i < m_max; i++)
 560         {
 561                 monster_type *m_ptr;
 562
 563                 /* Acquire monster */
 564                 m_ptr = &m_list[i];
 565
 566                 /* Skip live monsters */
 567                 if (m_ptr->r_idx) continue;
 568
 569                 /* Count monsters */
 570                 m_cnt++;
 571
 572                 /* Use this monster */
 573                 return (i);
 574         }
 575
 576
 577         /* Warn the player (except during dungeon creation) */
 578 #ifdef JP
 579         if (character_dungeon) msg_print("¥â¥ó¥¹¥¿¡¼¤¬Â¿¤¹¤®¤ë¡ª");
 580 #else
 581         if (character_dungeon) msg_print("Too many monsters!");
 582 #endif
 583
 584
 585         /* Try not to crash */
 586         return (0);
 587 }
 588
 589
 590
 591
 592 /*
 593  * Hack -- the "type" of the current "summon specific"
 594  */
 595 static int summon_specific_type = 0;
 596
 597
 598 /*
 599  * Hack -- the index of the summoning monster
 600  */
 601 static int summon_specific_who = -1;
 602
 603
 604 static bool summon_unique_okay = FALSE;
 605
 606
 607 static bool summon_specific_aux(int r_idx)
 608 {
 609         monster_race *r_ptr = &r_info[r_idx];
 610         int okay = FALSE;
 611
 612         /* Check our requirements */
 613         switch (summon_specific_type)
 614         {
 615                 case SUMMON_ANT:
 616                 {
 617                         okay = (r_ptr->d_char == 'a');
 618                         break;
 619                 }
 620
 621                 case SUMMON_SPIDER:
 622                 {
 623                         okay = (r_ptr->d_char == 'S');
 624                         break;
 625                 }
 626
 627                 case SUMMON_HOUND:
 628                 {
 629                         okay = ((r_ptr->d_char == 'C') || (r_ptr->d_char == 'Z'));
 630                         break;
 631                 }
 632
 633                 case SUMMON_HYDRA:
 634                 {
 635                         okay = (r_ptr->d_char == 'M');
 636                         break;
 637                 }
 638
 639                 case SUMMON_ANGEL:
 640                 {
 641                         okay = (r_ptr->d_char == 'A' && ((r_ptr->flags3 & RF3_EVIL) || (r_ptr->flags3 & RF3_GOOD)));
 642                         break;
 643                 }
 644
 645                 case SUMMON_DEMON:
 646                 {
 647                         okay = (r_ptr->flags3 & RF3_DEMON);
 648                         break;
 649                 }
 650
 651                 case SUMMON_UNDEAD:
 652                 {
 653                         okay = (r_ptr->flags3 & RF3_UNDEAD);
 654                         break;
 655                 }
 656
 657                 case SUMMON_DRAGON:
 658                 {
 659                         okay = (r_ptr->flags3 & RF3_DRAGON);
 660                         break;
 661                 }
 662
 663                 case SUMMON_HI_UNDEAD:
 664                 {
 665                         okay = ((r_ptr->d_char == 'L') ||
 666                                 (r_ptr->d_char == 'V') ||
 667                                 (r_ptr->d_char == 'W'));
 668                         break;
 669                 }
 670
 671                 case SUMMON_HI_DRAGON:
 672                 {
 673                         okay = (r_ptr->d_char == 'D');
 674                         break;
 675                 }
 676
 677                 case SUMMON_HI_DEMON:
 678                 {
 679                         okay = (((r_ptr->d_char == 'U') ||
 680                                  (r_ptr->d_char == 'H') ||
 681                                  (r_ptr->d_char == 'B')) &&
 682                                 (r_ptr->flags3 & RF3_DEMON)) ? TRUE : FALSE;
 683                         break;
 684                 }
 685
 686                 case SUMMON_AMBERITES:
 687                 {
 688                         okay = (r_ptr->flags3 & (RF3_AMBERITE)) ? TRUE : FALSE;
 689                         break;
 690                 }
 691
 692                 case SUMMON_UNIQUE:
 693                 {
 694                         okay = (r_ptr->flags1 & (RF1_UNIQUE)) ? TRUE : FALSE;
 695                         break;
 696                 }
 697
 698                 case SUMMON_BIZARRE1:
 699                 {
 700                         okay = (r_ptr->d_char == 'm');
 701                         break;
 702                 }
 703                 case SUMMON_BIZARRE2:
 704                 {
 705                         okay = (r_ptr->d_char == 'b');
 706                         break;
 707                 }
 708                 case SUMMON_BIZARRE3:
 709                 {
 710                         okay = (r_ptr->d_char == 'Q');
 711                         break;
 712                 }
 713
 714                 case SUMMON_BIZARRE4:
 715                 {
 716                         okay = (r_ptr->d_char == 'v');
 717                         break;
 718                 }
 719
 720                 case SUMMON_BIZARRE5:
 721                 {
 722                         okay = (r_ptr->d_char == '$');
 723                         break;
 724                 }
 725
 726                 case SUMMON_BIZARRE6:
 727                 {
 728                         okay = ((r_ptr->d_char == '!') ||
 729                                  (r_ptr->d_char == '?') ||
 730                                  (r_ptr->d_char == '=') ||
 731                                  (r_ptr->d_char == '$') ||
 732                                  (r_ptr->d_char == '|'));
 733                         break;
 734                 }
 735
 736                 case SUMMON_GOLEM:
 737                 {
 738                         okay = (r_ptr->d_char == 'g');
 739                         break;
 740                 }
 741
 742                 case SUMMON_CYBER:
 743                 {
 744                         okay = ((r_ptr->d_char == 'U') &&
 745                                 (r_ptr->flags4 & RF4_ROCKET));
 746                         break;
 747                 }
 748
 749
 750                 case SUMMON_KIN:
 751                 {
 752                         okay = ((r_ptr->d_char == summon_kin_type) && (r_idx != MON_HAGURE));
 753                         break;
 754                 }
 755
 756                 case SUMMON_DAWN:
 757                 {
 758                         okay = (r_idx == MON_DAWN);
 759                         break;
 760                 }
 761
 762                 case SUMMON_ANIMAL:
 763                 {
 764                         okay = (r_ptr->flags3 & (RF3_ANIMAL));
 765                         break;
 766                 }
 767
 768                 case SUMMON_ANIMAL_RANGER:
 769                 {
 770                         okay = ((r_ptr->flags3 & (RF3_ANIMAL)) &&
 771                                (strchr("abcflqrwBCHIJKMRS", r_ptr->d_char)) &&
 772                                !(r_ptr->flags3 & (RF3_DRAGON)) &&
 773                                !(r_ptr->flags3 & (RF3_EVIL)) &&
 774                                !(r_ptr->flags3 & (RF3_UNDEAD)) &&
 775                                !(r_ptr->flags3 & (RF3_DEMON)) &&
 776                                !(r_ptr->flags2 & (RF2_MULTIPLY)) &&
 777                                !(r_ptr->flags4 || r_ptr->flags5 || r_ptr->flags6));
 778                         break;
 779                 }
 780
 781                 case SUMMON_HI_DRAGON_LIVING:
 782                 {
 783                         okay = ((r_ptr->d_char == 'D') && monster_living(r_ptr));
 784                         break;
 785                 }
 786
 787                 case SUMMON_LIVING:
 788                 {
 789                         okay = monster_living(r_ptr);
 790                         break;
 791                 }
 792
 793                 case SUMMON_PHANTOM:
 794                 {
 795                         okay = (r_idx == MON_PHANTOM_B || r_idx == MON_PHANTOM_W);
 796                         break;
 797                 }
 798
 799                 case SUMMON_BLUE_HORROR:
 800                 {
 801                         okay = (r_idx == MON_BLUE_HORROR);
 802                         break;
 803                 }
 804
 805                 case SUMMON_ELEMENTAL:
 806                 {
 807                         okay = (r_ptr->d_char == 'E');
 808                         break;
 809                 }
 810
 811                 case SUMMON_VORTEX:
 812                 {
 813                         okay = (r_ptr->d_char == 'v');
 814                         break;
 815                 }
 816
 817                 case SUMMON_HYBRID:
 818                 {
 819                         okay = (r_ptr->d_char == 'H');
 820                         break;
 821                 }
 822
 823                 case SUMMON_BIRD:
 824                 {
 825                         okay = (r_ptr->d_char == 'B');
 826                         break;
 827                 }
 828
 829                 case SUMMON_KAMIKAZE:
 830                 {
 831                         int i;
 832                         for (i = 0; i < 4; i++)
 833                                 if (r_ptr->blow[i].method == RBM_EXPLODE) okay = TRUE;
 834                         break;
 835                 }
 836
 837                 case SUMMON_KAMIKAZE_LIVING:
 838                 {
 839                         int i;
 840
 841                         for (i = 0; i < 4; i++)
 842                                 if (r_ptr->blow[i].method == RBM_EXPLODE) okay = TRUE;
 843                         okay = (okay && monster_living(r_ptr));
 844                         break;
 845                 }
 846
 847                 case SUMMON_MANES:
 848                 {
 849                         okay = (r_idx == MON_MANES);
 850                         break;
 851                 }
 852
 853                 case SUMMON_LOUSE:
 854                 {
 855                         okay = (r_idx == MON_LOUSE);
 856                         break;
 857                 }
 858
 859                 case SUMMON_GUARDIANS:
 860                 {
 861                         okay = (r_ptr->flags7 & RF7_GUARDIAN);
 862                         break;
 863                 }
 864
 865                 case SUMMON_KNIGHTS:
 866                 {
 867                         okay = ((r_idx == MON_NOV_PALADIN) ||
 868                                 (r_idx == MON_NOV_PALADIN_G) ||
 869                                 (r_idx == MON_PALADIN) ||
 870                                 (r_idx == MON_W_KNIGHT) ||
 871                                 (r_idx == MON_ULTRA_PALADIN) ||
 872                                 (r_idx == MON_KNI_TEMPLAR));
 873                         break;
 874                 }
 875
 876                 case SUMMON_EAGLES:
 877                 {
 878                         okay = (r_ptr->d_char == 'B' &&
 879                                 (r_ptr->flags8 & RF8_WILD_MOUNTAIN) &&
 880                                 (r_ptr->flags8 & RF8_WILD_ONLY));
 881                         break;
 882                 }
 883
 884                 case SUMMON_PIRANHAS:
 885                 {
 886                         okay = (r_idx == MON_PIRANHA);
 887                         break;
 888                 }
 889
 890                 case SUMMON_ARMAGE_GOOD:
 891                 {
 892                         okay = (r_ptr->d_char == 'A' && (r_ptr->flags3 & RF3_GOOD));
 893                         break;
 894                 }
 895
 896                 case SUMMON_ARMAGE_EVIL:
 897                 {
 898                         okay = ((r_ptr->flags3 & RF3_DEMON) ||
 899                                 (r_ptr->d_char == 'A' && (r_ptr->flags3 & RF3_EVIL)));
 900                         break;
 901                 }
 902         }
 903
 904         /* Result */
 905         /* Since okay is int, "return (okay);" is not correct. */
 906         return (bool)(okay ? TRUE : FALSE);
 907 }
 908
 909
 910 static int chameleon_change_m_idx = 0;
 911
 912
 913 /*
 914  * Some dungeon types restrict the possible monsters.
 915  * Return TRUE is the monster is OK and FALSE otherwise
 916  */
 917 static bool restrict_monster_to_dungeon(int r_idx)
 918 {
 919         dungeon_info_type *d_ptr = &d_info[dungeon_type];
 920         monster_race *r_ptr = &r_info[r_idx];
 921         byte a;
 922
 923         if (d_ptr->flags1 & DF1_CHAMELEON)
 924         {
 925                 if (chameleon_change_m_idx) return TRUE;
 926         }
 927         if (d_ptr->flags1 & DF1_NO_MAGIC)
 928         {
 929                 if (r_idx != MON_CHAMELEON &&
 930                     r_ptr->freq_spell &&
 931                     !(r_ptr->flags4 & RF4_NOMAGIC_MASK) &&
 932                     !(r_ptr->flags5 & RF5_NOMAGIC_MASK) &&
 933                     !(r_ptr->flags6 & RF6_NOMAGIC_MASK))
 934                         return FALSE;
 935         }
 936         if (d_ptr->flags1 & DF1_NO_MELEE)
 937         {
 938                 if (r_idx == MON_CHAMELEON) return TRUE;
 939                 if (!(r_ptr->flags4 & (RF4_BOLT_MASK | RF4_BEAM_MASK | RF4_BALL_MASK)) &&
 940                     !(r_ptr->flags5 & (RF5_BOLT_MASK | RF5_BEAM_MASK | RF5_BALL_MASK | RF5_CAUSE_1 | RF5_CAUSE_2 | RF5_CAUSE_3 | RF5_CAUSE_4 | RF5_MIND_BLAST | RF5_BRAIN_SMASH)) &&
 941                     !(r_ptr->flags6 & (RF6_BOLT_MASK | RF6_BEAM_MASK | RF6_BALL_MASK)))
 942                         return FALSE;
 943         }
 944         if (d_ptr->flags1 & DF1_BEGINNER)
 945         {
 946                 if (r_ptr->level > dun_level)
 947                         return FALSE;
 948         }
 949
 950         if (d_ptr->special_div >= 64) return TRUE;
 951         if (summon_specific_type && !(d_ptr->flags1 & DF1_CHAMELEON)) return TRUE;
 952
 953         switch (d_ptr->mode)
 954         {
 955         case DUNGEON_MODE_AND:
 956                 if (d_ptr->mflags1)
 957                 {
 958                         if ((d_ptr->mflags1 & r_ptr->flags1) != d_ptr->mflags1)
 959                                 return FALSE;
 960                 }
 961                 if (d_ptr->mflags2)
 962                 {
 963                         if ((d_ptr->mflags2 & r_ptr->flags2) != d_ptr->mflags2)
 964                                 return FALSE;
 965                 }
 966                 if (d_ptr->mflags3)
 967                 {
 968                         if ((d_ptr->mflags3 & r_ptr->flags3) != d_ptr->mflags3)
 969                                 return FALSE;
 970                 }
 971                 if (d_ptr->mflags4)
 972                 {
 973                         if ((d_ptr->mflags4 & r_ptr->flags4) != d_ptr->mflags4)
 974                                 return FALSE;
 975                 }
 976                 if (d_ptr->mflags5)
 977                 {
 978                         if ((d_ptr->mflags5 & r_ptr->flags5) != d_ptr->mflags5)
 979                                 return FALSE;
 980                 }
 981                 if (d_ptr->mflags6)
 982                 {
 983                         if ((d_ptr->mflags6 & r_ptr->flags6) != d_ptr->mflags6)
 984                                 return FALSE;
 985                 }
 986                 if (d_ptr->mflags7)
 987                 {
 988                         if ((d_ptr->mflags7 & r_ptr->flags7) != d_ptr->mflags7)
 989                                 return FALSE;
 990                 }
 991                 if (d_ptr->mflags8)
 992                 {
 993                         if ((d_ptr->mflags8 & r_ptr->flags8) != d_ptr->mflags8)
 994                                 return FALSE;
 995                 }
 996                 if (d_ptr->mflags9)
 997                 {
 998                         if ((d_ptr->mflags9 & r_ptr->flags9) != d_ptr->mflags9)
 999                                 return FALSE;
1000                 }
1001                 if (d_ptr->mflagsr)
1002                 {
1003                         if ((d_ptr->mflagsr & r_ptr->flagsr) != d_ptr->mflagsr)
1004                                 return FALSE;
1005                 }
1006                 for (a = 0; a < 5; a++)
1007                         if (d_ptr->r_char[a] && (d_ptr->r_char[a] != r_ptr->d_char)) return FALSE;
1008
1009                 return TRUE;
1010
1011         case DUNGEON_MODE_NAND:
1012                 if (d_ptr->mflags1)
1013                 {
1014                         if ((d_ptr->mflags1 & r_ptr->flags1) != d_ptr->mflags1)
1015                                 return TRUE;
1016                 }
1017                 if (d_ptr->mflags2)
1018                 {
1019                         if ((d_ptr->mflags2 & r_ptr->flags2) != d_ptr->mflags2)
1020                                 return TRUE;
1021                 }
1022                 if (d_ptr->mflags3)
1023                 {
1024                         if ((d_ptr->mflags3 & r_ptr->flags3) != d_ptr->mflags3)
1025                                 return TRUE;
1026                 }
1027                 if (d_ptr->mflags4)
1028                 {
1029                         if ((d_ptr->mflags4 & r_ptr->flags4) != d_ptr->mflags4)
1030                                 return TRUE;
1031                 }
1032                 if (d_ptr->mflags5)
1033                 {
1034                         if ((d_ptr->mflags5 & r_ptr->flags5) != d_ptr->mflags5)
1035                                 return TRUE;
1036                 }
1037                 if (d_ptr->mflags6)
1038                 {
1039                         if ((d_ptr->mflags6 & r_ptr->flags6) != d_ptr->mflags6)
1040                                 return TRUE;
1041                 }
1042                 if (d_ptr->mflags7)
1043                 {
1044                         if ((d_ptr->mflags7 & r_ptr->flags7) != d_ptr->mflags7)
1045                                 return TRUE;
1046                 }
1047                 if (d_ptr->mflags8)
1048                 {
1049                         if ((d_ptr->mflags8 & r_ptr->flags8) != d_ptr->mflags8)
1050                                 return TRUE;
1051                 }
1052                 if (d_ptr->mflags9)
1053                 {
1054                         if ((d_ptr->mflags9 & r_ptr->flags9) != d_ptr->mflags9)
1055                                 return TRUE;
1056                 }
1057                 if (d_ptr->mflagsr)
1058                 {
1059                         if ((d_ptr->mflagsr & r_ptr->flagsr) != d_ptr->mflagsr)
1060                                 return TRUE;
1061                 }
1062                 for (a = 0; a < 5; a++)
1063                         if (d_ptr->r_char[a] && (d_ptr->r_char[a] != r_ptr->d_char)) return TRUE;
1064
1065                 return FALSE;
1066
1067         case DUNGEON_MODE_OR:
1068                 if (r_ptr->flags1 & d_ptr->mflags1) return TRUE;
1069                 if (r_ptr->flags2 & d_ptr->mflags2) return TRUE;
1070                 if (r_ptr->flags3 & d_ptr->mflags3) return TRUE;
1071                 if (r_ptr->flags4 & d_ptr->mflags4) return TRUE;
1072                 if (r_ptr->flags5 & d_ptr->mflags5) return TRUE;
1073                 if (r_ptr->flags6 & d_ptr->mflags6) return TRUE;
1074                 if (r_ptr->flags7 & d_ptr->mflags7) return TRUE;
1075                 if (r_ptr->flags8 & d_ptr->mflags8) return TRUE;
1076                 if (r_ptr->flags9 & d_ptr->mflags9) return TRUE;
1077                 if (r_ptr->flagsr & d_ptr->mflagsr) return TRUE;
1078                 for (a = 0; a < 5; a++)
1079                         if (d_ptr->r_char[a] == r_ptr->d_char) return TRUE;
1080
1081                 return FALSE;
1082
1083         case DUNGEON_MODE_NOR:
1084                 if (r_ptr->flags1 & d_ptr->mflags1) return FALSE;
1085                 if (r_ptr->flags2 & d_ptr->mflags2) return FALSE;
1086                 if (r_ptr->flags3 & d_ptr->mflags3) return FALSE;
1087                 if (r_ptr->flags4 & d_ptr->mflags4) return FALSE;
1088                 if (r_ptr->flags5 & d_ptr->mflags5) return FALSE;
1089                 if (r_ptr->flags6 & d_ptr->mflags6) return FALSE;
1090                 if (r_ptr->flags7 & d_ptr->mflags7) return FALSE;
1091                 if (r_ptr->flags8 & d_ptr->mflags8) return FALSE;
1092                 if (r_ptr->flags9 & d_ptr->mflags9) return FALSE;
1093                 if (r_ptr->flagsr & d_ptr->mflagsr) return FALSE;
1094                 for (a = 0; a < 5; a++)
1095                         if (d_ptr->r_char[a] == r_ptr->d_char) return FALSE;
1096
1097                 return TRUE;
1098         }
1099
1100         return TRUE;
1101 }
1102
1103 /*
1104  * Apply a "monster restriction function" to the "monster allocation table"
1105  */
1106 errr get_mon_num_prep(monster_hook_type monster_hook,
1107                                           monster_hook_type monster_hook2)
1108 {
1109         int i;
1110
1111         /* Todo: Check the hooks for non-changes */
1112
1113         /* Set the new hooks */
1114         get_mon_num_hook = monster_hook;
1115         get_mon_num2_hook = monster_hook2;
1116
1117         /* Scan the allocation table */
1118         for (i = 0; i < alloc_race_size; i++)
1119         {
1120                 monster_race    *r_ptr;
1121
1122                 /* Get the entry */
1123                 alloc_entry *entry = &alloc_race_table[i];
1124
1125                 entry->prob2 = 0;
1126                 r_ptr = &r_info[entry->index];
1127
1128                 /* Skip monsters which don't pass the restriction */
1129                 if ((get_mon_num_hook && !((*get_mon_num_hook)(entry->index))) ||
1130                     (get_mon_num2_hook && !((*get_mon_num2_hook)(entry->index))))
1131                         continue;
1132
1133                 if (!p_ptr->inside_battle && !chameleon_change_m_idx &&
1134                     summon_specific_type != SUMMON_GUARDIANS)
1135                 {
1136                         /* Hack -- don't create questors */
1137                         if (r_ptr->flags1 & RF1_QUESTOR)
1138                                 continue;
1139
1140                         if (r_ptr->flags7 & RF7_GUARDIAN)
1141                                 continue;
1142
1143                         /* Depth Monsters never appear out of depth */
1144                         if ((r_ptr->flags1 & (RF1_FORCE_DEPTH)) &&
1145                             (r_ptr->level > dun_level))
1146                                 continue;
1147                 }
1148
1149                 /* Accept this monster */
1150                 entry->prob2 = entry->prob1;
1151
1152                 if (dun_level && (!p_ptr->inside_quest || is_fixed_quest_idx(p_ptr->inside_quest)) && !restrict_monster_to_dungeon(entry->index) && !p_ptr->inside_battle)
1153                 {
1154                         int hoge = entry->prob2 * d_info[dungeon_type].special_div;
1155                         entry->prob2 = hoge / 64;
1156                         if (randint0(64) < (hoge & 0x3f)) entry->prob2++;
1157                 }
1158         }
1159
1160         /* Success */
1161         return (0);
1162 }
1163
1164
1165 static int mysqrt(int n)
1166 {
1167         int tmp = n>>1;
1168         int tasu = 10;
1169         int kaeriti = 1;
1170
1171         if (!tmp)
1172         {
1173                 if (n) return 1;
1174                 else return 0;
1175         }
1176
1177         while(tmp)
1178         {
1179                 if ((n/tmp) < tmp)
1180                 {
1181                         tmp >>= 1;
1182                 }
1183                 else break;
1184         }
1185         kaeriti = tmp;
1186         while(tasu)
1187         {
1188                 if ((n/tmp) < tmp)
1189                 {
1190                         tasu--;
1191                         tmp = kaeriti;
1192                 }
1193                 else
1194                 {
1195                         kaeriti = tmp;
1196                         tmp += tasu;
1197                 }
1198         }
1199         return kaeriti;
1200 }
1201
1202 /*
1203  * Choose a monster race that seems "appropriate" to the given level
1204  *
1205  * This function uses the "prob2" field of the "monster allocation table",
1206  * and various local information, to calculate the "prob3" field of the
1207  * same table, which is then used to choose an "appropriate" monster, in
1208  * a relatively efficient manner.
1209  *
1210  * Note that "town" monsters will *only* be created in the town, and
1211  * "normal" monsters will *never* be created in the town, unless the
1212  * "level" is "modified", for example, by polymorph or summoning.
1213  *
1214  * There is a small chance (1/50) of "boosting" the given depth by
1215  * a small amount (up to four levels), except in the town.
1216  *
1217  * It is (slightly) more likely to acquire a monster of the given level
1218  * than one of a lower level.  This is done by choosing several monsters
1219  * appropriate to the given level and keeping the "hardest" one.
1220  *
1221  * Note that if no monsters are "appropriate", then this function will
1222  * fail, and return zero, but this should *almost* never happen.
1223  */
1224 s16b get_mon_num(int level)
1225 {
1226         int                     i, j, p;
1227
1228         int                     r_idx;
1229
1230         long            value, total;
1231
1232         monster_race    *r_ptr;
1233
1234         alloc_entry             *table = alloc_race_table;
1235
1236         int pls_kakuritu, pls_level;
1237         int hoge=mysqrt(level*10000L);
1238
1239         if (level > MAX_DEPTH - 1) level = MAX_DEPTH - 1;
1240
1241         if ((dungeon_turn > hoge*(TURNS_PER_TICK*500L)) && !level)
1242         {
1243                 pls_kakuritu = MAX(2, NASTY_MON-((dungeon_turn/(TURNS_PER_TICK*2500L)-hoge/10)));
1244                 pls_level = MIN(8,3 + dungeon_turn/(TURNS_PER_TICK*20000L)-hoge/40);
1245         }
1246         else
1247         {
1248                 pls_kakuritu = NASTY_MON;
1249                 pls_level = 2;
1250         }
1251
1252         if (d_info[dungeon_type].flags1 & DF1_MAZE)
1253         {
1254                 pls_kakuritu = MIN(pls_kakuritu/2, pls_kakuritu-10);
1255                 if (pls_kakuritu < 2) pls_kakuritu = 2;
1256                 pls_level += 2;
1257                 level += 3;
1258         }
1259
1260         /* Boost the level */
1261         if ((level > 0) && !p_ptr->inside_battle && !(d_info[dungeon_type].flags1 & DF1_BEGINNER))
1262         {
1263                 /* Nightmare mode allows more out-of depth monsters */
1264                 if (ironman_nightmare && !randint0(pls_kakuritu))
1265                 {
1266                         /* What a bizarre calculation */
1267                         level = 1 + (level * MAX_DEPTH / randint1(MAX_DEPTH));
1268                 }
1269                 else
1270                 {
1271                         /* Occasional "nasty" monster */
1272                         if (!randint0(pls_kakuritu))
1273                         {
1274                                 /* Pick a level bonus */
1275                                 int d = MIN(5, level/10) + pls_level;
1276
1277                                 /* Boost the level */
1278                                 level += d;
1279                         }
1280
1281                         /* Occasional "nasty" monster */
1282                         if (!randint0(pls_kakuritu))
1283                         {
1284                                 /* Pick a level bonus */
1285                                 int d = MIN(5, level/10) + pls_level;
1286
1287                                 /* Boost the level */
1288                                 level += d;
1289                         }
1290                 }
1291         }
1292
1293
1294         /* Reset total */
1295         total = 0L;
1296
1297         /* Process probabilities */
1298         for (i = 0; i < alloc_race_size; i++)
1299         {
1300                 /* Monsters are sorted by depth */
1301                 if (table[i].level > level) break;
1302
1303                 /* Default */
1304                 table[i].prob3 = 0;
1305
1306                 /* Access the "r_idx" of the chosen monster */
1307                 r_idx = table[i].index;
1308
1309                 /* Access the actual race */
1310                 r_ptr = &r_info[r_idx];
1311
1312                 if (!p_ptr->inside_battle && !chameleon_change_m_idx)
1313                 {
1314                         /* Hack -- "unique" monsters must be "unique" */
1315                         if (((r_ptr->flags1 & (RF1_UNIQUE)) ||
1316                              (r_ptr->flags7 & (RF7_NAZGUL))) &&
1317                             (r_ptr->cur_num >= r_ptr->max_num))
1318                         {
1319                                 continue;
1320                         }
1321
1322                         if ((r_ptr->flags7 & (RF7_UNIQUE2)) &&
1323                             (r_ptr->cur_num >= 1))
1324                         {
1325                                 continue;
1326                         }
1327
1328                         if (r_idx == MON_BANORLUPART)
1329                         {
1330                                 if (r_info[MON_BANOR].cur_num > 0) continue;
1331                                 if (r_info[MON_LUPART].cur_num > 0) continue;
1332                         }
1333                 }
1334
1335                 /* Accept */
1336                 table[i].prob3 = table[i].prob2;
1337
1338                 /* Total */
1339                 total += table[i].prob3;
1340         }
1341
1342         /* No legal monsters */
1343         if (total <= 0) return (0);
1344
1345
1346         /* Pick a monster */
1347         value = randint0(total);
1348
1349         /* Find the monster */
1350         for (i = 0; i < alloc_race_size; i++)
1351         {
1352                 /* Found the entry */
1353                 if (value < table[i].prob3) break;
1354
1355                 /* Decrement */
1356                 value = value - table[i].prob3;
1357         }
1358
1359
1360         /* Power boost */
1361         p = randint0(100);
1362
1363         /* Try for a "harder" monster once (50%) or twice (10%) */
1364         if (p < 60)
1365         {
1366                 /* Save old */
1367                 j = i;
1368
1369                 /* Pick a monster */
1370                 value = randint0(total);
1371
1372                 /* Find the monster */
1373                 for (i = 0; i < alloc_race_size; i++)
1374                 {
1375                         /* Found the entry */
1376                         if (value < table[i].prob3) break;
1377
1378                         /* Decrement */
1379                         value = value - table[i].prob3;
1380                 }
1381
1382                 /* Keep the "best" one */
1383                 if (table[i].level < table[j].level) i = j;
1384         }
1385
1386         /* Try for a "harder" monster twice (10%) */
1387         if (p < 10)
1388         {
1389                 /* Save old */
1390                 j = i;
1391
1392                 /* Pick a monster */
1393                 value = randint0(total);
1394
1395                 /* Find the monster */
1396                 for (i = 0; i < alloc_race_size; i++)
1397                 {
1398                         /* Found the entry */
1399                         if (value < table[i].prob3) break;
1400
1401                         /* Decrement */
1402                         value = value - table[i].prob3;
1403                 }
1404
1405                 /* Keep the "best" one */
1406                 if (table[i].level < table[j].level) i = j;
1407         }
1408
1409         /* Result */
1410         return (table[i].index);
1411 }
1412
1413
1414
1415
1416
1417 /*
1418  * Build a string describing a monster in some way.
1419  *
1420  * We can correctly describe monsters based on their visibility.
1421  * We can force all monsters to be treated as visible or invisible.
1422  * We can build nominatives, objectives, possessives, or reflexives.
1423  * We can selectively pronominalize hidden, visible, or all monsters.
1424  * We can use definite or indefinite descriptions for hidden monsters.
1425  * We can use definite or indefinite descriptions for visible monsters.
1426  *
1427  * Pronominalization involves the gender whenever possible and allowed,
1428  * so that by cleverly requesting pronominalization / visibility, you
1429  * can get messages like "You hit someone.  She screams in agony!".
1430  *
1431  * Reflexives are acquired by requesting Objective plus Possessive.
1432  *
1433  * If no m_ptr arg is given (?), the monster is assumed to be hidden,
1434  * unless the "Assume Visible" mode is requested.
1435  *
1436  * If no r_ptr arg is given, it is extracted from m_ptr and r_info
1437  * If neither m_ptr nor r_ptr is given, the monster is assumed to
1438  * be neuter, singular, and hidden (unless "Assume Visible" is set),
1439  * in which case you may be in trouble... :-)
1440  *
1441  * I am assuming that no monster name is more than 70 characters long,
1442  * so that "char desc[80];" is sufficiently large for any result.
1443  *
1444  * Mode Flags:
1445  *  MD_OBJECTIVE      --> Objective (or Reflexive)
1446  *  MD_POSSESSIVE     --> Possessive (or Reflexive)
1447  *  MD_INDEF_HIDDEN   --> Use indefinites for hidden monsters ("something")
1448  *  MD_INDEF_VISIBLE  --> Use indefinites for visible monsters ("a kobold")
1449  *  MD_PRON_HIDDEN    --> Pronominalize hidden monsters
1450  *  MD_PRON_VISIBLE   --> Pronominalize visible monsters
1451  *  MD_ASSUME_HIDDEN  --> Assume the monster is hidden
1452  *  MD_ASSUME_VISIBLE --> Assume the monster is visible
1453  *  MD_TRUE_NAME      --> Chameleon's true name
1454  *  MD_IGNORE_HALLU   --> Ignore hallucination, and penetrate shape change
1455  *
1456  * Useful Modes:
1457  *  0x00 --> Full nominative name ("the kobold") or "it"
1458  *  MD_INDEF_HIDDEN --> Full nominative name ("the kobold") or "something"
1459  *  MD_ASSUME_VISIBLE --> Genocide resistance name ("the kobold")
1460  *  MD_ASSUME_VISIBLE | MD_INDEF_VISIBLE --> Killing name ("a kobold")
1461  *  MD_PRON_VISIBLE | MD_POSSESSIVE
1462  *    --> Possessive, genderized if visable ("his") or "its"
1463  *  MD_PRON_VISIBLE | MD_POSSESSIVE | MD_OBJECTIVE
1464  *    --> Reflexive, genderized if visable ("himself") or "itself"
1465  */
1466 void monster_desc(char *desc, monster_type *m_ptr, int mode)
1467 {
1468         cptr            res;
1469         monster_race    *r_ptr;
1470
1471         cptr            name;
1472         char            buf[128];
1473         char            silly_name[1024];
1474         bool            seen, pron;
1475         bool            named = FALSE;
1476
1477         r_ptr = &r_info[m_ptr->ap_r_idx];
1478
1479         /* Mode of MD_TRUE_NAME will reveal Chameleon's true name */
1480         if (mode & MD_TRUE_NAME) name = (r_name + real_r_ptr(m_ptr)->name);
1481         else name = (r_name + r_ptr->name);
1482
1483         /* Are we hallucinating? (Idea from Nethack...) */
1484         if (p_ptr->image && !(mode & MD_IGNORE_HALLU))
1485         {
1486                 if (one_in_(2))
1487                 {
1488 #ifdef JP
1489                         if (!get_rnd_line("silly_j.txt", m_ptr->r_idx, silly_name))
1490 #else
1491                         if (!get_rnd_line("silly.txt", m_ptr->r_idx, silly_name))
1492 #endif
1493
1494                                 named = TRUE;
1495                 }
1496
1497                 if (!named)
1498                 {
1499                         monster_race *hallu_race;
1500
1501                         do
1502                         {
1503                                 hallu_race = &r_info[randint1(max_r_idx - 1)];
1504                         }
1505                         while (hallu_race->flags1 & RF1_UNIQUE);
1506
1507                         strcpy(silly_name, (r_name + hallu_race->name));
1508                 }
1509
1510                 /* Better not strcpy it, or we could corrupt r_info... */
1511                 name = silly_name;
1512         }
1513
1514         /* Can we "see" it (exists + forced, or visible + not unforced) */
1515         seen = (m_ptr && ((mode & MD_ASSUME_VISIBLE) || (!(mode & MD_ASSUME_HIDDEN) && m_ptr->ml)));
1516
1517         /* Sexed Pronouns (seen and allowed, or unseen and allowed) */
1518         pron = (m_ptr && ((seen && (mode & MD_PRON_VISIBLE)) || (!seen && (mode & MD_PRON_HIDDEN))));
1519
1520
1521         /* First, try using pronouns, or describing hidden monsters */
1522         if (!seen || pron)
1523         {
1524                 /* an encoding of the monster "sex" */
1525                 int kind = 0x00;
1526
1527                 /* Extract the gender (if applicable) */
1528                 if (r_ptr->flags1 & (RF1_FEMALE)) kind = 0x20;
1529                 else if (r_ptr->flags1 & (RF1_MALE)) kind = 0x10;
1530
1531                 /* Ignore the gender (if desired) */
1532                 if (!m_ptr || !pron) kind = 0x00;
1533
1534
1535                 /* Assume simple result */
1536 #ifdef JP
1537                 res = "²¿¤«";
1538 #else
1539                 res = "it";
1540 #endif
1541
1542
1543                 /* Brute force: split on the possibilities */
1544                 switch (kind + (mode & (MD_INDEF_HIDDEN | MD_POSSESSIVE | MD_OBJECTIVE)))
1545                 {
1546                         /* Neuter, or unknown */
1547 #ifdef JP
1548                         case 0x00:                                                    res = "²¿¤«"; break;
1549                         case 0x00 + (MD_OBJECTIVE):                                   res = "²¿¤«"; break;
1550                         case 0x00 + (MD_POSSESSIVE):                                  res = "²¿¤«¤Î"; break;
1551                         case 0x00 + (MD_POSSESSIVE | MD_OBJECTIVE):                   res = "²¿¤«¼«¿È"; break;
1552                         case 0x00 + (MD_INDEF_HIDDEN):                                res = "²¿¤«"; break;
1553                         case 0x00 + (MD_INDEF_HIDDEN | MD_OBJECTIVE):                 res = "²¿¤«"; break;
1554                         case 0x00 + (MD_INDEF_HIDDEN | MD_POSSESSIVE):                res = "²¿¤«"; break;
1555                         case 0x00 + (MD_INDEF_HIDDEN | MD_POSSESSIVE | MD_OBJECTIVE): res = "¤½¤ì¼«¿È"; break;
1556 #else
1557                         case 0x00:                                                    res = "it"; break;
1558                         case 0x00 + (MD_OBJECTIVE):                                   res = "it"; break;
1559                         case 0x00 + (MD_POSSESSIVE):                                  res = "its"; break;
1560                         case 0x00 + (MD_POSSESSIVE | MD_OBJECTIVE):                   res = "itself"; break;
1561                         case 0x00 + (MD_INDEF_HIDDEN):                                res = "something"; break;
1562                         case 0x00 + (MD_INDEF_HIDDEN | MD_OBJECTIVE):                 res = "something"; break;
1563                         case 0x00 + (MD_INDEF_HIDDEN | MD_POSSESSIVE):                res = "something's"; break;
1564                         case 0x00 + (MD_INDEF_HIDDEN | MD_POSSESSIVE | MD_OBJECTIVE): res = "itself"; break;
1565 #endif
1566
1567
1568                         /* Male (assume human if vague) */
1569 #ifdef JP
1570                         case 0x10:                                                    res = "Èà"; break;
1571                         case 0x10 + (MD_OBJECTIVE):                                   res = "Èà"; break;
1572                         case 0x10 + (MD_POSSESSIVE):                                  res = "Èà¤Î"; break;
1573                         case 0x10 + (MD_POSSESSIVE | MD_OBJECTIVE):                   res = "Èà¼«¿È"; break;
1574                         case 0x10 + (MD_INDEF_HIDDEN):                                res = "Ã¯¤«"; break;
1575                         case 0x10 + (MD_INDEF_HIDDEN | MD_OBJECTIVE):                 res = "Ã¯¤«"; break;
1576                         case 0x10 + (MD_INDEF_HIDDEN | MD_POSSESSIVE):                res = "Ã¯¤«¤Î"; break;
1577                         case 0x10 + (MD_INDEF_HIDDEN | MD_POSSESSIVE | MD_OBJECTIVE): res = "Èà¼«¿È"; break;
1578 #else
1579                         case 0x10:                                                    res = "he"; break;
1580                         case 0x10 + (MD_OBJECTIVE):                                   res = "him"; break;
1581                         case 0x10 + (MD_POSSESSIVE):                                  res = "his"; break;
1582                         case 0x10 + (MD_POSSESSIVE | MD_OBJECTIVE):                   res = "himself"; break;
1583                         case 0x10 + (MD_INDEF_HIDDEN):                                res = "someone"; break;
1584                         case 0x10 + (MD_INDEF_HIDDEN | MD_OBJECTIVE):                 res = "someone"; break;
1585                         case 0x10 + (MD_INDEF_HIDDEN | MD_POSSESSIVE):                res = "someone's"; break;
1586                         case 0x10 + (MD_INDEF_HIDDEN | MD_POSSESSIVE | MD_OBJECTIVE): res = "himself"; break;
1587 #endif
1588
1589
1590                         /* Female (assume human if vague) */
1591 #ifdef JP
1592                         case 0x20:                                                    res = "Èà½÷"; break;
1593                         case 0x20 + (MD_OBJECTIVE):                                   res = "Èà½÷"; break;
1594                         case 0x20 + (MD_POSSESSIVE):                                  res = "Èà½÷¤Î"; break;
1595                         case 0x20 + (MD_POSSESSIVE | MD_OBJECTIVE):                   res = "Èà½÷¼«¿È"; break;
1596                         case 0x20 + (MD_INDEF_HIDDEN):                                res = "Ã¯¤«"; break;
1597                         case 0x20 + (MD_INDEF_HIDDEN | MD_OBJECTIVE):                 res = "Ã¯¤«"; break;
1598                         case 0x20 + (MD_INDEF_HIDDEN | MD_POSSESSIVE):                res = "Ã¯¤«¤Î"; break;
1599                         case 0x20 + (MD_INDEF_HIDDEN | MD_POSSESSIVE | MD_OBJECTIVE): res = "Èà½÷¼«¿È"; break;
1600 #else
1601                         case 0x20:                                                    res = "she"; break;
1602                         case 0x20 + (MD_OBJECTIVE):                                   res = "her"; break;
1603                         case 0x20 + (MD_POSSESSIVE):                                  res = "her"; break;
1604                         case 0x20 + (MD_POSSESSIVE | MD_OBJECTIVE):                   res = "herself"; break;
1605                         case 0x20 + (MD_INDEF_HIDDEN):                                res = "someone"; break;
1606                         case 0x20 + (MD_INDEF_HIDDEN | MD_OBJECTIVE):                 res = "someone"; break;
1607                         case 0x20 + (MD_INDEF_HIDDEN | MD_POSSESSIVE):                res = "someone's"; break;
1608                         case 0x20 + (MD_INDEF_HIDDEN | MD_POSSESSIVE | MD_OBJECTIVE): res = "herself"; break;
1609 #endif
1610                 }
1611
1612                 /* Copy the result */
1613                 (void)strcpy(desc, res);
1614         }
1615
1616
1617         /* Handle visible monsters, "reflexive" request */
1618         else if ((mode & (MD_POSSESSIVE | MD_OBJECTIVE)) == (MD_POSSESSIVE | MD_OBJECTIVE))
1619         {
1620                 /* The monster is visible, so use its gender */
1621 #ifdef JP
1622                 if (r_ptr->flags1 & (RF1_FEMALE)) strcpy(desc, "Èà½÷¼«¿È");
1623                 else if (r_ptr->flags1 & (RF1_MALE)) strcpy(desc, "Èà¼«¿È");
1624                 else strcpy(desc, "¤½¤ì¼«¿È");
1625 #else
1626                 if (r_ptr->flags1 & RF1_FEMALE) strcpy(desc, "herself");
1627                 else if (r_ptr->flags1 & RF1_MALE) strcpy(desc, "himself");
1628                 else strcpy(desc, "itself");
1629 #endif
1630         }
1631
1632
1633         /* Handle all other visible monster requests */
1634         else
1635         {
1636                 /* Tanuki? */
1637                 if (is_pet(m_ptr) && m_ptr->ap_r_idx != m_ptr->r_idx)
1638                 {
1639 #ifdef JP
1640                         char *t;
1641                         strcpy(buf, name);
1642                         t = buf;
1643                         while(strncmp(t, "¡Ù", 2) && *t) t++;
1644                         if (*t)
1645                         {
1646                                 *t = '\0';
1647                                 (void)sprintf(desc, "%s¡©¡Ù", buf);
1648                         }
1649                         else
1650                                 (void)sprintf(desc, "%s¡©", name);
1651 #else
1652                         (void)sprintf(desc, "%s?", name);
1653 #endif
1654                 }
1655                 else
1656
1657                 /* It could be a Unique */
1658                 if ((r_ptr->flags1 & RF1_UNIQUE) && !(p_ptr->image && !(mode & MD_IGNORE_HALLU)))
1659                 {
1660                         /* Start with the name (thus nominative and objective) */
1661                         if ((m_ptr->mflag2 & MFLAG2_CHAMELEON) && !(mode & MD_TRUE_NAME))
1662                         {
1663 #ifdef JP
1664                                 char *t;
1665                                 strcpy(buf, name);
1666                                 t = buf;
1667                                 while (strncmp(t, "¡Ù", 2) && *t) t++;
1668                                 if (*t)
1669                                 {
1670                                         *t = '\0';
1671                                         (void)sprintf(desc, "%s¡©¡Ù", buf);
1672                                 }
1673                                 else
1674                                         (void)sprintf(desc, "%s¡©", name);
1675 #else
1676                                 (void)sprintf(desc, "%s?", name);
1677 #endif
1678                         }
1679                         else if ((cave[m_ptr->fy][m_ptr->fx].m_idx == p_ptr->riding) || !p_ptr->inside_battle)
1680                                 (void)strcpy(desc, name);
1681                         else
1682 #ifdef JP
1683                                 (void)sprintf(desc, "%s¤â¤É¤", name);
1684 #else
1685                                 (void)sprintf(desc, "fake %s", name);
1686 #endif
1687                 }
1688
1689                 /* It could be an indefinite monster */
1690                 else if (mode & MD_INDEF_VISIBLE)
1691                 {
1692                         /* XXX Check plurality for "some" */
1693
1694                         /* Indefinite monsters need an indefinite article */
1695 #ifdef JP
1696                         (void)strcpy(desc, "");
1697 #else
1698                         (void)strcpy(desc, is_a_vowel(name[0]) ? "an " : "a ");
1699 #endif
1700
1701                         (void)strcat(desc, name);
1702                 }
1703
1704                 /* It could be a normal, definite, monster */
1705                 else
1706                 {
1707                         /* Definite monsters need a definite article */
1708                         if (is_pet(m_ptr))
1709 #ifdef JP
1710                                 (void)strcpy(desc, "¤¢¤Ê¤¿¤Î");
1711 #else
1712                                 (void)strcpy(desc, "your ");
1713 #endif
1714
1715                         else
1716 #ifdef JP
1717                                 (void)strcpy(desc, "");
1718 #else
1719                                 (void)strcpy(desc, "the ");
1720 #endif
1721
1722                         (void)strcat(desc, name);
1723                 }
1724
1725                 if (m_ptr->nickname)
1726                 {
1727 #ifdef JP
1728                         sprintf(buf,"¡Ö%s¡×",quark_str(m_ptr->nickname));
1729 #else
1730                         sprintf(buf," called %s",quark_str(m_ptr->nickname));
1731 #endif
1732                         strcat(desc,buf);
1733                 }
1734
1735                 if (player_bold(m_ptr->fy, m_ptr->fx))
1736                 {
1737 #ifdef JP
1738                         strcat(desc,"(¾èÇÏÃæ)");
1739 #else
1740                         strcat(desc,"(riding)");
1741 #endif
1742                 }
1743
1744                 if ((mode & MD_IGNORE_HALLU) && (m_ptr->mflag2 & MFLAG2_CHAMELEON))
1745                 {
1746                         if (r_ptr->flags1 & RF1_UNIQUE)
1747                         {
1748 #ifdef JP
1749                                 strcat(desc,"(¥«¥á¥ì¥ª¥ó¤Î²¦)");
1750 #else
1751                                 strcat(desc,"(Chameleon Lord)");
1752 #endif
1753                         }
1754                         else
1755                         {
1756 #ifdef JP
1757                                 strcat(desc,"(¥«¥á¥ì¥ª¥ó)");
1758 #else
1759                                 strcat(desc,"(Chameleon)");
1760 #endif
1761                         }
1762                 }
1763
1764                 if ((mode & MD_IGNORE_HALLU) && m_ptr->ap_r_idx != m_ptr->r_idx)
1765                 {
1766                         strcat(desc, format("(%s)", r_name + r_info[m_ptr->r_idx].name));
1767                 }
1768
1769                 /* Handle the Possessive as a special afterthought */
1770                 if (mode & MD_POSSESSIVE)
1771                 {
1772                         /* XXX Check for trailing "s" */
1773
1774                         /* Simply append "apostrophe" and "s" */
1775 #ifdef JP
1776                         (void)strcat(desc, "¤Î");
1777 #else
1778                         (void)strcat(desc, "'s");
1779 #endif
1780                 }
1781         }
1782 }
1783
1784
1785
1786
1787 /*
1788  * Learn about a monster (by "probing" it)
1789  *
1790  * Return the number of new flags learnt.  -Mogami-
1791  */
1792 int lore_do_probe(int r_idx)
1793 {
1794         monster_race *r_ptr = &r_info[r_idx];
1795         int i, n = 0;
1796         byte tmp_byte;
1797
1798         /* Maximal info about awareness */
1799         if (r_ptr->r_wake != MAX_UCHAR) n++;
1800         if (r_ptr->r_ignore != MAX_UCHAR) n++;
1801         r_ptr->r_wake = r_ptr->r_ignore = MAX_UCHAR;
1802
1803         /* Observe "maximal" attacks */
1804         for (i = 0; i < 4; i++)
1805         {
1806                 /* Examine "actual" blows */
1807                 if (r_ptr->blow[i].effect || r_ptr->blow[i].method)
1808                 {
1809                         /* Maximal observations */
1810                         if (r_ptr->r_blows[i] != MAX_UCHAR) n++;
1811                         r_ptr->r_blows[i] = MAX_UCHAR;
1812                 }
1813         }
1814
1815         /* Maximal drops */
1816         tmp_byte =
1817                 (((r_ptr->flags1 & RF1_DROP_4D2) ? 8 : 0) +
1818                  ((r_ptr->flags1 & RF1_DROP_3D2) ? 6 : 0) +
1819                  ((r_ptr->flags1 & RF1_DROP_2D2) ? 4 : 0) +
1820                  ((r_ptr->flags1 & RF1_DROP_1D2) ? 2 : 0) +
1821                  ((r_ptr->flags1 & RF1_DROP_90)  ? 1 : 0) +
1822                  ((r_ptr->flags1 & RF1_DROP_60)  ? 1 : 0));
1823
1824         /* Only "valid" drops */
1825         if (!(r_ptr->flags1 & RF1_ONLY_GOLD))
1826         {
1827                 if (r_ptr->r_drop_item != tmp_byte) n++;
1828                 r_ptr->r_drop_item = tmp_byte;
1829         }
1830         if (!(r_ptr->flags1 & RF1_ONLY_ITEM))
1831         {
1832                 if (r_ptr->r_drop_gold != tmp_byte) n++;
1833                 r_ptr->r_drop_gold = tmp_byte;
1834         }
1835
1836         /* Observe many spells */
1837         if (r_ptr->r_cast_spell != MAX_UCHAR) n++;
1838         r_ptr->r_cast_spell = MAX_UCHAR;
1839
1840         /* Count unknown flags */
1841         for (i = 0; i < 32; i++)
1842         {
1843                 if (!(r_ptr->r_flags1 & (1L << i)) &&
1844                     (r_ptr->flags1 & (1L << i))) n++;
1845                 if (!(r_ptr->r_flags2 & (1L << i)) &&
1846                     (r_ptr->flags2 & (1L << i))) n++;
1847                 if (!(r_ptr->r_flags3 & (1L << i)) &&
1848                     (r_ptr->flags3 & (1L << i))) n++;
1849                 if (!(r_ptr->r_flags4 & (1L << i)) &&
1850                     (r_ptr->flags4 & (1L << i))) n++;
1851                 if (!(r_ptr->r_flags5 & (1L << i)) &&
1852                     (r_ptr->flags5 & (1L << i))) n++;
1853                 if (!(r_ptr->r_flags6 & (1L << i)) &&
1854                     (r_ptr->flags6 & (1L << i))) n++;
1855                 if (!(r_ptr->r_flagsr & (1L << i)) &&
1856                     (r_ptr->flagsr & (1L << i))) n++;
1857
1858                 /* r_flags7 is actually unused */
1859 #if 0
1860                 if (!(r_ptr->r_flags7 & (1L << i)) &&
1861                     (r_ptr->flags7 & (1L << i))) n++;
1862 #endif
1863         }
1864
1865         /* Know all the flags */
1866         r_ptr->r_flags1 = r_ptr->flags1;
1867         r_ptr->r_flags2 = r_ptr->flags2;
1868         r_ptr->r_flags3 = r_ptr->flags3;
1869         r_ptr->r_flags4 = r_ptr->flags4;
1870         r_ptr->r_flags5 = r_ptr->flags5;
1871         r_ptr->r_flags6 = r_ptr->flags6;
1872         r_ptr->r_flagsr = r_ptr->flagsr;
1873
1874         /* r_flags7 is actually unused */
1875         /* r_ptr->r_flags7 = r_ptr->flags7; */
1876
1877         /* Know about evolution */
1878         if (!(r_ptr->r_xtra1 & MR1_SINKA)) n++;
1879         r_ptr->r_xtra1 |= MR1_SINKA;
1880
1881         /* Update monster recall window */
1882         if (p_ptr->monster_race_idx == r_idx)
1883         {
1884                 /* Window stuff */
1885                 p_ptr->window |= (PW_MONSTER);
1886         }
1887
1888         /* Return the number of new flags learnt */
1889         return n;
1890 }
1891
1892
1893 /*
1894  * Take note that the given monster just dropped some treasure
1895  *
1896  * Note that learning the "GOOD"/"GREAT" flags gives information
1897  * about the treasure (even when the monster is killed for the first
1898  * time, such as uniques, and the treasure has not been examined yet).
1899  *
1900  * This "indirect" method is used to prevent the player from learning
1901  * exactly how much treasure a monster can drop from observing only
1902  * a single example of a drop.  This method actually observes how much
1903  * gold and items are dropped, and remembers that information to be
1904  * described later by the monster recall code.
1905  */
1906 void lore_treasure(int m_idx, int num_item, int num_gold)
1907 {
1908         monster_type *m_ptr = &m_list[m_idx];
1909
1910         monster_race *r_ptr = &r_info[m_ptr->r_idx];
1911
1912         /* If the monster doesn't have original appearance, don't note */
1913         if (!is_original_ap(m_ptr)) return;
1914
1915         /* Note the number of things dropped */
1916         if (num_item > r_ptr->r_drop_item) r_ptr->r_drop_item = num_item;
1917         if (num_gold > r_ptr->r_drop_gold) r_ptr->r_drop_gold = num_gold;
1918
1919         /* Hack -- memorize the good/great flags */
1920         if (r_ptr->flags1 & (RF1_DROP_GOOD)) r_ptr->r_flags1 |= (RF1_DROP_GOOD);
1921         if (r_ptr->flags1 & (RF1_DROP_GREAT)) r_ptr->r_flags1 |= (RF1_DROP_GREAT);
1922
1923         /* Update monster recall window */
1924         if (p_ptr->monster_race_idx == m_ptr->r_idx)
1925         {
1926                 /* Window stuff */
1927                 p_ptr->window |= (PW_MONSTER);
1928         }
1929 }
1930
1931
1932
1933 void sanity_blast(monster_type *m_ptr, bool necro)
1934 {
1935         bool happened = FALSE;
1936         int power = 100;
1937
1938         if (p_ptr->inside_battle || !character_dungeon) return;
1939
1940         if (!necro)
1941         {
1942                 char            m_name[80];
1943                 monster_race    *r_ptr = &r_info[m_ptr->ap_r_idx];
1944
1945                 power = r_ptr->level / 2;
1946
1947                 monster_desc(m_name, m_ptr, 0);
1948
1949                 if (!(r_ptr->flags1 & RF1_UNIQUE))
1950                 {
1951                         if (r_ptr->flags1 & RF1_FRIENDS)
1952                         power /= 2;
1953                 }
1954                 else power *= 2;
1955
1956                 if (!hack_mind)
1957                         return; /* No effect yet, just loaded... */
1958
1959                 if (!m_ptr->ml)
1960                         return; /* Cannot see it for some reason */
1961
1962                 if (!(r_ptr->flags2 & RF2_ELDRITCH_HORROR))
1963                         return; /* oops */
1964
1965
1966
1967                 if (is_pet(m_ptr))
1968                         return; /* Pet eldritch horrors are safe most of the time */
1969
1970                 if (randint1(100) > power) return;
1971
1972                 if (saving_throw(p_ptr->skill_sav - power))
1973                 {
1974                         return; /* Save, no adverse effects */
1975                 }
1976
1977                 if (p_ptr->image)
1978                 {
1979                         /* Something silly happens... */
1980 #ifdef JP
1981                         msg_format("%s%s¤Î´é¤ò¸«¤Æ¤·¤Þ¤Ã¤¿¡ª",
1982                                 funny_desc[randint0(MAX_SAN_FUNNY)], m_name);
1983 #else
1984                         msg_format("You behold the %s visage of %s!",
1985                                 funny_desc[randint0(MAX_SAN_FUNNY)], m_name);
1986 #endif
1987
1988
1989                         if (one_in_(3))
1990                         {
1991                                 msg_print(funny_comments[randint0(MAX_SAN_COMMENT)]);
1992                                 p_ptr->image = p_ptr->image + randint1(r_ptr->level);
1993                         }
1994
1995                         return; /* Never mind; we can't see it clearly enough */
1996                 }
1997
1998                 /* Something frightening happens... */
1999 #ifdef JP
2000                 msg_format("%s%s¤Î´é¤ò¸«¤Æ¤·¤Þ¤Ã¤¿¡ª",
2001                         horror_desc[randint0(MAX_SAN_HORROR)], m_name);
2002 #else
2003                 msg_format("You behold the %s visage of %s!",
2004                         horror_desc[randint0(MAX_SAN_HORROR)], m_name);
2005 #endif
2006
2007                 r_ptr->r_flags2 |= RF2_ELDRITCH_HORROR;
2008
2009                 /* Demon characters are unaffected */
2010                 if (prace_is_(RACE_IMP) || prace_is_(RACE_DEMON) || (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_DEMON)) return;
2011                 if (p_ptr->wizard) return;
2012
2013                 /* Undead characters are 50% likely to be unaffected */
2014                 if (prace_is_(RACE_SKELETON) || prace_is_(RACE_ZOMBIE)
2015                         || prace_is_(RACE_VAMPIRE) || prace_is_(RACE_SPECTRE) ||
2016                     (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_UNDEAD))
2017                 {
2018                         if (saving_throw(25 + p_ptr->lev)) return;
2019                 }
2020         }
2021         else
2022         {
2023 #ifdef JP
2024 msg_print("¥Í¥¯¥í¥Î¥ß¥³¥ó¤òÆÉ¤ó¤ÇÀµµ¤¤ò¼º¤Ã¤¿¡ª");
2025 #else
2026                 msg_print("Your sanity is shaken by reading the Necronomicon!");
2027 #endif
2028
2029         }
2030
2031         if (!saving_throw(p_ptr->skill_sav - power)) /* Mind blast */
2032         {
2033                 if (!p_ptr->resist_conf)
2034                 {
2035                         (void)set_confused(p_ptr->confused + randint0(4) + 4);
2036                 }
2037                 if (!p_ptr->resist_chaos && one_in_(3))
2038                 {
2039                         (void)set_image(p_ptr->image + randint0(250) + 150);
2040                 }
2041                 return;
2042         }
2043
2044         if (!saving_throw(p_ptr->skill_sav - power)) /* Lose int & wis */
2045         {
2046                 do_dec_stat(A_INT);
2047                 do_dec_stat(A_WIS);
2048                 return;
2049         }
2050
2051         if (!saving_throw(p_ptr->skill_sav - power)) /* Brain smash */
2052         {
2053                 if (!p_ptr->resist_conf)
2054                 {
2055                         (void)set_confused(p_ptr->confused + randint0(4) + 4);
2056                 }
2057                 if (!p_ptr->free_act)
2058                 {
2059                         (void)set_paralyzed(p_ptr->paralyzed + randint0(4) + 4);
2060                 }
2061                 while (randint0(100) > p_ptr->skill_sav)
2062                         (void)do_dec_stat(A_INT);
2063                 while (randint0(100) > p_ptr->skill_sav)
2064                         (void)do_dec_stat(A_WIS);
2065                 if (!p_ptr->resist_chaos)
2066                 {
2067                         (void)set_image(p_ptr->image + randint0(250) + 150);
2068                 }
2069                 return;
2070         }
2071
2072         if (!saving_throw(p_ptr->skill_sav - power)) /* Amnesia */
2073         {
2074
2075                 if (lose_all_info())
2076 #ifdef JP
2077 msg_print("¤¢¤Þ¤ê¤Î¶²ÉÝ¤ËÁ´¤Æ¤Î¤³¤È¤òËº¤ì¤Æ¤·¤Þ¤Ã¤¿¡ª");
2078 #else
2079                         msg_print("You forget everything in your utmost terror!");
2080 #endif
2081
2082                 return;
2083         }
2084
2085         if (saving_throw(p_ptr->skill_sav - power))
2086         {
2087                 return;
2088         }
2089
2090         /* Else gain permanent insanity */
2091         if ((p_ptr->muta3 & MUT3_MORONIC) && /*(p_ptr->muta2 & MUT2_BERS_RAGE) &&*/
2092                 ((p_ptr->muta2 & MUT2_COWARDICE) || (p_ptr->resist_fear)) &&
2093                 ((p_ptr->muta2 & MUT2_HALLU) || (p_ptr->resist_chaos)))
2094         {
2095                 /* The poor bastard already has all possible insanities! */
2096                 return;
2097         }
2098
2099         while (!happened)
2100         {
2101                 switch (randint1(21))
2102                 {
2103                         case 1:
2104                                 if (!(p_ptr->muta3 & MUT3_MORONIC) && one_in_(5))
2105                                 {
2106                                         if ((p_ptr->stat_use[A_INT] < 4) && (p_ptr->stat_use[A_WIS] < 4))
2107                                         {
2108 #ifdef JP
2109 msg_print("¤¢¤Ê¤¿¤Ï´°àú¤ÊÇÏ¼¯¤Ë¤Ê¤Ã¤¿¤è¤¦¤Êµ¤¤¬¤·¤¿¡£¤·¤«¤·¤½¤ì¤Ï¸µ¡¹¤À¤Ã¤¿¡£");
2110 #else
2111                                                 msg_print("You turn into an utter moron!");
2112 #endif
2113                                         }
2114                                         else
2115                                         {
2116 #ifdef JP
2117 msg_print("¤¢¤Ê¤¿¤Ï´°àú¤ÊÇÏ¼¯¤Ë¤Ê¤Ã¤¿¡ª");
2118 #else
2119                                                 msg_print("You turn into an utter moron!");
2120 #endif
2121                                         }
2122
2123                                         if (p_ptr->muta3 & MUT3_HYPER_INT)
2124                                         {
2125 #ifdef JP
2126 msg_print("¤¢¤Ê¤¿¤ÎÇ¾¤ÏÀ¸ÂÎ¥³¥ó¥Ô¥å¡¼¥¿¤Ç¤Ï¤Ê¤¯¤Ê¤Ã¤¿¡£");
2127 #else
2128                                                 msg_print("Your brain is no longer a living computer.");
2129 #endif
2130
2131                                                 p_ptr->muta3 &= ~(MUT3_HYPER_INT);
2132                                         }
2133                                         p_ptr->muta3 |= MUT3_MORONIC;
2134                                         happened = TRUE;
2135                                 }
2136                                 break;
2137                         case 2:
2138                         case 3:
2139                         case 4:
2140                         case 5:
2141                         case 6:
2142                         case 7:
2143                         case 8:
2144                         case 9:
2145                         case 10:
2146                         case 11:
2147                                 if (!(p_ptr->muta2 & MUT2_COWARDICE) && !p_ptr->resist_fear)
2148                                 {
2149 #ifdef JP
2150 msg_print("¤¢¤Ê¤¿¤Ï¥Ñ¥é¥Î¥¤¥¢¤Ë¤Ê¤Ã¤¿¡ª");
2151 #else
2152                                         msg_print("You become paranoid!");
2153 #endif
2154
2155
2156                                         /* Duh, the following should never happen, but anyway... */
2157                                         if (p_ptr->muta3 & MUT3_FEARLESS)
2158                                         {
2159 #ifdef JP
2160 msg_print("¤¢¤Ê¤¿¤Ï¤â¤¦¶²¤ìÃÎ¤é¤º¤Ç¤Ï¤Ê¤¯¤Ê¤Ã¤¿¡£");
2161 #else
2162                                                 msg_print("You are no longer fearless.");
2163 #endif
2164
2165                                                 p_ptr->muta3 &= ~(MUT3_FEARLESS);
2166                                         }
2167
2168                                         p_ptr->muta2 |= MUT2_COWARDICE;
2169                                         happened = TRUE;
2170                                 }
2171                                 break;
2172                         case 12:
2173                         case 13:
2174                         case 14:
2175                         case 15:
2176                         case 16:
2177                         case 17:
2178                         case 18:
2179                         case 19:
2180                         case 20:
2181                         case 21:
2182                                 if (!(p_ptr->muta2 & MUT2_HALLU) && !p_ptr->resist_chaos)
2183                                 {
2184 #ifdef JP
2185 msg_print("¸¸³Ð¤ò¤Ò¤µ¯¤³¤¹Àº¿ÀºøÍð¤Ë´Ù¤Ã¤¿¡ª");
2186 #else
2187                                         msg_print("You are afflicted by a hallucinatory insanity!");
2188 #endif
2189
2190                                         p_ptr->muta2 |= MUT2_HALLU;
2191                                         happened = TRUE;
2192                                 }
2193                                 break;
2194                         default:
2195                                 if (!(p_ptr->muta2 & MUT2_BERS_RAGE))
2196                                 {
2197 #ifdef JP
2198 msg_print("·ãÎõ¤Ê´¶¾ð¤ÎÈ¯ºî¤Ë¤ª¤½¤ï¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡ª");
2199 #else
2200                                         msg_print("You become subject to fits of berserk rage!");
2201 #endif
2202
2203                                         p_ptr->muta2 |= MUT2_BERS_RAGE;
2204                                         happened = TRUE;
2205                                 }
2206                                 break;
2207                 }
2208         }
2209
2210         p_ptr->update |= PU_BONUS;
2211         handle_stuff();
2212 }
2213
2214
2215 /*
2216  * This function updates the monster record of the given monster
2217  *
2218  * This involves extracting the distance to the player (if requested),
2219  * and then checking for visibility (natural, infravision, see-invis,
2220  * telepathy), updating the monster visibility flag, redrawing (or
2221  * erasing) the monster when its visibility changes, and taking note
2222  * of any interesting monster flags (cold-blooded, invisible, etc).
2223  *
2224  * Note the new "mflag" field which encodes several monster state flags,
2225  * including "view" for when the monster is currently in line of sight,
2226  * and "mark" for when the monster is currently visible via detection.
2227  *
2228  * The only monster fields that are changed here are "cdis" (the
2229  * distance from the player), "ml" (visible to the player), and
2230  * "mflag" (to maintain the "MFLAG_VIEW" flag).
2231  *
2232  * Note the special "update_monsters()" function which can be used to
2233  * call this function once for every monster.
2234  *
2235  * Note the "full" flag which requests that the "cdis" field be updated,
2236  * this is only needed when the monster (or the player) has moved.
2237  *
2238  * Every time a monster moves, we must call this function for that
2239  * monster, and update the distance, and the visibility.  Every time
2240  * the player moves, we must call this function for every monster, and
2241  * update the distance, and the visibility.  Whenever the player "state"
2242  * changes in certain ways ("blindness", "infravision", "telepathy",
2243  * and "see invisible"), we must call this function for every monster,
2244  * and update the visibility.
2245  *
2246  * Routines that change the "illumination" of a grid must also call this
2247  * function for any monster in that grid, since the "visibility" of some
2248  * monsters may be based on the illumination of their grid.
2249  *
2250  * Note that this function is called once per monster every time the
2251  * player moves.  When the player is running, this function is one
2252  * of the primary bottlenecks, along with "update_view()" and the
2253  * "process_monsters()" code, so efficiency is important.
2254  *
2255  * Note the optimized "inline" version of the "distance()" function.
2256  *
2257  * A monster is "visible" to the player if (1) it has been detected
2258  * by the player, (2) it is close to the player and the player has
2259  * telepathy, or (3) it is close to the player, and in line of sight
2260  * of the player, and it is "illuminated" by some combination of
2261  * infravision, torch light, or permanent light (invisible monsters
2262  * are only affected by "light" if the player can see invisible).
2263  *
2264  * Monsters which are not on the current panel may be "visible" to
2265  * the player, and their descriptions will include an "offscreen"
2266  * reference.  Currently, offscreen monsters cannot be targetted
2267  * or viewed directly, but old targets will remain set.  XXX XXX
2268  *
2269  * The player can choose to be disturbed by several things, including
2270  * "disturb_move" (monster which is viewable moves in some way), and
2271  * "disturb_near" (monster which is "easily" viewable moves in some
2272  * way).  Note that "moves" includes "appears" and "disappears".
2273  */
2274 void update_mon(int m_idx, bool full)
2275 {
2276         monster_type *m_ptr = &m_list[m_idx];
2277
2278         monster_race *r_ptr = &r_info[m_ptr->r_idx];
2279
2280         bool do_disturb = disturb_move;
2281
2282         int d;
2283
2284         /* Current location */
2285         int fy = m_ptr->fy;
2286         int fx = m_ptr->fx;
2287
2288         /* Seen at all */
2289         bool flag = FALSE;
2290
2291         /* Seen by vision */
2292         bool easy = FALSE;
2293
2294         /* Non-Ninja player in the darkness */
2295         bool in_darkness = (d_info[dungeon_type].flags1 & DF1_DARKNESS) && !p_ptr->see_nocto;
2296
2297         /* Do disturb? */
2298         if (disturb_high)
2299         {
2300                 monster_race *ap_r_ptr = &r_info[m_ptr->ap_r_idx];
2301
2302                 if (ap_r_ptr->r_tkills && ap_r_ptr->level >= p_ptr->lev)
2303                         do_disturb = TRUE;
2304         }
2305
2306         /* Compute distance */
2307         if (full)
2308         {
2309                 /* Distance components */
2310                 int dy = (py > fy) ? (py - fy) : (fy - py);
2311                 int dx = (px > fx) ? (px - fx) : (fx - px);
2312
2313                 /* Approximate distance */
2314                 d = (dy > dx) ? (dy + (dx>>1)) : (dx + (dy>>1));
2315
2316                 /* Restrict distance */
2317                 if (d > 255) d = 255;
2318
2319                 if (!d) d = 1;
2320
2321                 /* Save the distance */
2322                 m_ptr->cdis = d;
2323         }
2324
2325         /* Extract distance */
2326         else
2327         {
2328                 /* Extract the distance */
2329                 d = m_ptr->cdis;
2330         }
2331
2332
2333         /* Detected */
2334         if (m_ptr->mflag2 & (MFLAG2_MARK)) flag = TRUE;
2335
2336
2337         /* Nearby */
2338         if (d <= (in_darkness ? MAX_SIGHT / 2 : MAX_SIGHT))
2339         {
2340                 if (!in_darkness || (d <= MAX_SIGHT / 4))
2341                 {
2342                         if (p_ptr->special_defense & KATA_MUSOU)
2343                         {
2344                                 /* Detectable */
2345                                 flag = TRUE;
2346
2347                                 if (is_original_ap(m_ptr))
2348                                 {
2349                                         /* Hack -- Memorize mental flags */
2350                                         if (r_ptr->flags2 & (RF2_SMART)) r_ptr->r_flags2 |= (RF2_SMART);
2351                                         if (r_ptr->flags2 & (RF2_STUPID)) r_ptr->r_flags2 |= (RF2_STUPID);
2352                                 }
2353                         }
2354
2355                         /* Basic telepathy */
2356                         else if (p_ptr->telepathy)
2357                         {
2358                                 /* Empty mind, no telepathy */
2359                                 if (r_ptr->flags2 & (RF2_EMPTY_MIND))
2360                                 {
2361                                         /* Memorize flags */
2362                                         if (is_original_ap(m_ptr)) r_ptr->r_flags2 |= (RF2_EMPTY_MIND);
2363                                 }
2364
2365                                 /* Weird mind, occasional telepathy */
2366                                 else if (r_ptr->flags2 & (RF2_WEIRD_MIND))
2367                                 {
2368                                         /* One in ten individuals are detectable */
2369                                         if ((m_idx % 10) == 5)
2370                                         {
2371                                                 /* Detectable */
2372                                                 flag = TRUE;
2373
2374                                                 if (is_original_ap(m_ptr))
2375                                                 {
2376                                                         /* Memorize flags */
2377                                                         r_ptr->r_flags2 |= (RF2_WEIRD_MIND);
2378
2379                                                         /* Hack -- Memorize mental flags */
2380                                                         if (r_ptr->flags2 & (RF2_SMART)) r_ptr->r_flags2 |= (RF2_SMART);
2381                                                         if (r_ptr->flags2 & (RF2_STUPID)) r_ptr->r_flags2 |= (RF2_STUPID);
2382                                                 }
2383                                         }
2384                                 }
2385
2386                                 /* Normal mind, allow telepathy */
2387                                 else
2388                                 {
2389                                         /* Detectable */
2390                                         flag = TRUE;
2391
2392                                         if (is_original_ap(m_ptr))
2393                                         {
2394                                                 /* Hack -- Memorize mental flags */
2395                                                 if (r_ptr->flags2 & (RF2_SMART)) r_ptr->r_flags2 |= (RF2_SMART);
2396                                                 if (r_ptr->flags2 & (RF2_STUPID)) r_ptr->r_flags2 |= (RF2_STUPID);
2397                                         }
2398                                 }
2399                         }
2400
2401                         /* Magical sensing */
2402                         if ((p_ptr->esp_animal) && (r_ptr->flags3 & (RF3_ANIMAL)))
2403                         {
2404                                 flag = TRUE;
2405                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_ANIMAL);
2406                         }
2407
2408                         /* Magical sensing */
2409                         if ((p_ptr->esp_undead) && (r_ptr->flags3 & (RF3_UNDEAD)))
2410                         {
2411                                 flag = TRUE;
2412                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_UNDEAD);
2413                         }
2414
2415                         /* Magical sensing */
2416                         if ((p_ptr->esp_demon) && (r_ptr->flags3 & (RF3_DEMON)))
2417                         {
2418                                 flag = TRUE;
2419                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_DEMON);
2420                         }
2421
2422                         /* Magical sensing */
2423                         if ((p_ptr->esp_orc) && (r_ptr->flags3 & (RF3_ORC)))
2424                         {
2425                                 flag = TRUE;
2426                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_ORC);
2427                         }
2428
2429                         /* Magical sensing */
2430                         if ((p_ptr->esp_troll) && (r_ptr->flags3 & (RF3_TROLL)))
2431                         {
2432                                 flag = TRUE;
2433                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_TROLL);
2434                         }
2435
2436                         /* Magical sensing */
2437                         if ((p_ptr->esp_giant) && (r_ptr->flags3 & (RF3_GIANT)))
2438                         {
2439                                 flag = TRUE;
2440                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_GIANT);
2441                         }
2442
2443                         /* Magical sensing */
2444                         if ((p_ptr->esp_dragon) && (r_ptr->flags3 & (RF3_DRAGON)))
2445                         {
2446                                 flag = TRUE;
2447                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_DRAGON);
2448                         }
2449
2450                         /* Magical sensing */
2451                         if ((p_ptr->esp_human) && (r_ptr->flags2 & (RF2_HUMAN)))
2452                         {
2453                                 flag = TRUE;
2454                                 if (is_original_ap(m_ptr)) r_ptr->r_flags2 |= (RF2_HUMAN);
2455                         }
2456
2457                         /* Magical sensing */
2458                         if ((p_ptr->esp_evil) && (r_ptr->flags3 & (RF3_EVIL)))
2459                         {
2460                                 flag = TRUE;
2461                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_EVIL);
2462                         }
2463
2464                         /* Magical sensing */
2465                         if ((p_ptr->esp_good) && (r_ptr->flags3 & (RF3_GOOD)))
2466                         {
2467                                 flag = TRUE;
2468                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_GOOD);
2469                         }
2470
2471                         /* Magical sensing */
2472                         if ((p_ptr->esp_nonliving) &&
2473                             ((r_ptr->flags3 & (RF3_DEMON | RF3_UNDEAD | RF3_NONLIVING)) == RF3_NONLIVING))
2474                         {
2475                                 flag = TRUE;
2476                                 if (is_original_ap(m_ptr)) r_ptr->r_flags3 |= (RF3_NONLIVING);
2477                         }
2478
2479                         /* Magical sensing */
2480                         if ((p_ptr->esp_unique) && (r_ptr->flags1 & (RF1_UNIQUE)))
2481                         {
2482                                 flag = TRUE;
2483                                 if (is_original_ap(m_ptr)) r_ptr->r_flags1 |= (RF1_UNIQUE);
2484                         }
2485                 }
2486
2487                 /* Normal line of sight, and not blind */
2488                 if (player_has_los_bold(fy, fx) && !p_ptr->blind)
2489                 {
2490                         bool do_invisible = FALSE;
2491                         bool do_cold_blood = FALSE;
2492
2493                         /* Use "infravision" */
2494                         if (d <= p_ptr->see_infra)
2495                         {
2496                                 /* Handle "cold blooded" monsters */
2497                                 if ((r_ptr->flags2 & (RF2_COLD_BLOOD | RF2_AURA_FIRE)) == RF2_COLD_BLOOD)
2498                                 {
2499                                         /* Take note */
2500                                         do_cold_blood = TRUE;
2501                                 }
2502
2503                                 /* Handle "warm blooded" monsters */
2504                                 else
2505                                 {
2506                                         /* Easy to see */
2507                                         easy = flag = TRUE;
2508                                 }
2509                         }
2510
2511                         /* Use "illumination" */
2512                         if (player_can_see_bold(fy, fx))
2513                         {
2514                                 /* Handle "invisible" monsters */
2515                                 if (r_ptr->flags2 & (RF2_INVISIBLE))
2516                                 {
2517                                         /* Take note */
2518                                         do_invisible = TRUE;
2519
2520                                         /* See invisible */
2521                                         if (p_ptr->see_inv)
2522                                         {
2523                                                 /* Easy to see */
2524                                                 easy = flag = TRUE;
2525                                         }
2526                                 }
2527
2528                                 /* Handle "normal" monsters */
2529                                 else
2530                                 {
2531                                         /* Easy to see */
2532                                         easy = flag = TRUE;
2533                                 }
2534                         }
2535
2536                         /* Visible */
2537                         if (flag)
2538                         {
2539                                 if (is_original_ap(m_ptr))
2540                                 {
2541                                         /* Memorize flags */
2542                                         if (do_invisible) r_ptr->r_flags2 |= (RF2_INVISIBLE);
2543                                         if (do_cold_blood) r_ptr->r_flags2 |= (RF2_COLD_BLOOD);
2544                                 }
2545                         }
2546                 }
2547         }
2548
2549
2550         /* The monster is now visible */
2551         if (flag)
2552         {
2553                 /* It was previously unseen */
2554                 if (!m_ptr->ml)
2555                 {
2556                         /* Mark as visible */
2557                         m_ptr->ml = TRUE;
2558
2559                         /* Draw the monster */
2560                         lite_spot(fy, fx);
2561
2562                         /* Update health bar as needed */
2563                         if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
2564                         if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
2565
2566                         /* Hack -- Count "fresh" sightings */
2567                         if ((m_ptr->ap_r_idx == MON_KAGE) && (r_info[MON_KAGE].r_sights < MAX_SHORT))
2568                                 r_info[MON_KAGE].r_sights++;
2569                         else if (m_ptr->ap_r_idx == m_ptr->r_idx &&
2570                                  r_ptr->r_sights < MAX_SHORT) r_ptr->r_sights++;
2571
2572                         /* Eldritch Horror */
2573                         if (r_ptr->flags2 & RF2_ELDRITCH_HORROR)
2574                         {
2575                                 sanity_blast(m_ptr, FALSE);
2576                         }
2577
2578                         /* Disturb on appearance */
2579                         if (disturb_near && (projectable(m_ptr->fy, m_ptr->fx, py, px) && projectable(py, px, m_ptr->fy, m_ptr->fx)))
2580                         {
2581                                 if (disturb_pets || is_hostile(m_ptr))
2582                                         disturb(1, 0);
2583                         }
2584                 }
2585         }
2586
2587         /* The monster is not visible */
2588         else
2589         {
2590                 /* It was previously seen */
2591                 if (m_ptr->ml)
2592                 {
2593                         /* Mark as not visible */
2594                         m_ptr->ml = FALSE;
2595
2596                         /* Erase the monster */
2597                         lite_spot(fy, fx);
2598
2599                         /* Update health bar as needed */
2600                         if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
2601                         if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
2602
2603                         /* Disturb on disappearance */
2604                         if (do_disturb)
2605                         {
2606                                 if (disturb_pets || is_hostile(m_ptr))
2607                                         disturb(1, 0);
2608                         }
2609                 }
2610         }
2611
2612
2613         /* The monster is now easily visible */
2614         if (easy)
2615         {
2616                 /* Change */
2617                 if (!(m_ptr->mflag & (MFLAG_VIEW)))
2618                 {
2619                         /* Mark as easily visible */
2620                         m_ptr->mflag |= (MFLAG_VIEW);
2621
2622                         /* Disturb on appearance */
2623                         if (do_disturb)
2624                         {
2625                                 if (disturb_pets || is_hostile(m_ptr))
2626                                         disturb(1, 0);
2627                         }
2628                 }
2629         }
2630
2631         /* The monster is not easily visible */
2632         else
2633         {
2634                 /* Change */
2635                 if (m_ptr->mflag & (MFLAG_VIEW))
2636                 {
2637                         /* Mark as not easily visible */
2638                         m_ptr->mflag &= ~(MFLAG_VIEW);
2639
2640                         /* Disturb on disappearance */
2641                         if (do_disturb)
2642                         {
2643                                 if (disturb_pets || is_hostile(m_ptr))
2644                                         disturb(1, 0);
2645                         }
2646                 }
2647         }
2648 }
2649
2650
2651 /*
2652  * This function simply updates all the (non-dead) monsters (see above).
2653  */
2654 void update_monsters(bool full)
2655 {
2656         int i;
2657
2658         /* Update each (live) monster */
2659         for (i = 1; i < m_max; i++)
2660         {
2661                 monster_type *m_ptr = &m_list[i];
2662
2663                 /* Skip dead monsters */
2664                 if (!m_ptr->r_idx) continue;
2665
2666                 /* Update the monster */
2667                 update_mon(i, full);
2668         }
2669 }
2670
2671
2672 /*
2673  * Hack -- the index of the summoning monster
2674  */
2675 static bool monster_hook_chameleon_lord(int r_idx)
2676 {
2677         monster_race *r_ptr = &r_info[r_idx];
2678         monster_type *m_ptr = &m_list[chameleon_change_m_idx];
2679         monster_race *old_r_ptr = &r_info[m_ptr->r_idx];
2680
2681         if (!(r_ptr->flags1 & (RF1_UNIQUE))) return FALSE;
2682         if (r_ptr->flags7 & (RF7_FRIENDLY | RF7_CHAMELEON)) return FALSE;
2683
2684         if (ABS(r_ptr->level - r_info[MON_CHAMELEON_K].level) > 5) return FALSE;
2685
2686         if ((r_ptr->blow[0].method == RBM_EXPLODE) || (r_ptr->blow[1].method == RBM_EXPLODE) || (r_ptr->blow[2].method == RBM_EXPLODE) || (r_ptr->blow[3].method == RBM_EXPLODE))
2687                 return FALSE;
2688
2689         if (!monster_can_cross_terrain(cave[m_ptr->fy][m_ptr->fx].feat, r_ptr)) return FALSE;
2690
2691         /* Not born */
2692         if (!(old_r_ptr->flags7 & RF7_CHAMELEON))
2693         {
2694                 if (monster_has_hostile_align(m_ptr, 0, 0, r_ptr)) return FALSE;
2695         }
2696
2697         /* Born now */
2698         else if (summon_specific_who > 0)
2699         {
2700                 if (monster_has_hostile_align(&m_list[summon_specific_who], 0, 0, r_ptr)) return FALSE;
2701         }
2702
2703         return TRUE;
2704 }
2705
2706 static bool monster_hook_chameleon(int r_idx)
2707 {
2708         monster_race *r_ptr = &r_info[r_idx];
2709         monster_type *m_ptr = &m_list[chameleon_change_m_idx];
2710         monster_race *old_r_ptr = &r_info[m_ptr->r_idx];
2711
2712         if (r_ptr->flags1 & (RF1_UNIQUE)) return FALSE;
2713         if (r_ptr->flags2 & RF2_MULTIPLY) return FALSE;
2714         if (r_ptr->flags7 & (RF7_FRIENDLY | RF7_CHAMELEON)) return FALSE;
2715
2716         if ((r_ptr->blow[0].method == RBM_EXPLODE) || (r_ptr->blow[1].method == RBM_EXPLODE) || (r_ptr->blow[2].method == RBM_EXPLODE) || (r_ptr->blow[3].method == RBM_EXPLODE))
2717                 return FALSE;
2718
2719         if (!monster_can_cross_terrain(cave[m_ptr->fy][m_ptr->fx].feat, r_ptr)) return FALSE;
2720
2721         /* Not born */
2722         if (!(old_r_ptr->flags7 & RF7_CHAMELEON))
2723         {
2724                 if ((old_r_ptr->flags3 & RF3_GOOD) && !(r_ptr->flags3 & RF3_GOOD)) return FALSE;
2725                 if ((old_r_ptr->flags3 & RF3_EVIL) && !(r_ptr->flags3 & RF3_EVIL)) return FALSE;
2726                 if (!(old_r_ptr->flags3 & (RF3_GOOD | RF3_EVIL)) && (r_ptr->flags3 & (RF3_GOOD | RF3_EVIL))) return FALSE;
2727         }
2728
2729         /* Born now */
2730         else if (summon_specific_who > 0)
2731         {
2732                 if (monster_has_hostile_align(&m_list[summon_specific_who], 0, 0, r_ptr)) return FALSE;
2733         }
2734
2735         return (*(get_monster_hook()))(r_idx);
2736 }
2737
2738
2739 void choose_new_monster(int m_idx, bool born, int r_idx)
2740 {
2741         int oldmaxhp;
2742         monster_type *m_ptr = &m_list[m_idx];
2743         monster_race *r_ptr;
2744         char old_m_name[80];
2745         bool old_unique = FALSE;
2746
2747         if (r_info[m_ptr->r_idx].flags1 & RF1_UNIQUE)
2748                 old_unique = TRUE;
2749         if (old_unique && (r_idx == MON_CHAMELEON)) r_idx = MON_CHAMELEON_K;
2750         r_ptr = &r_info[r_idx];
2751
2752         monster_desc(old_m_name, m_ptr, 0);
2753
2754         if (!r_idx)
2755         {
2756                 int level;
2757
2758                 chameleon_change_m_idx = m_idx;
2759                 if (old_unique)
2760                         get_mon_num_prep(monster_hook_chameleon_lord, NULL);
2761                 else
2762                         get_mon_num_prep(monster_hook_chameleon, NULL);
2763
2764                 if (old_unique)
2765                         level = r_info[MON_CHAMELEON_K].level;
2766                 else if (!dun_level)
2767                         level = wilderness[p_ptr->wilderness_y][p_ptr->wilderness_x].level;
2768                 else
2769                         level = dun_level;
2770
2771                 if (d_info[dungeon_type].flags1 & DF1_CHAMELEON) level+= 2+randint1(3);
2772
2773                 r_idx = get_mon_num(level);
2774                 r_ptr = &r_info[r_idx];
2775
2776                 chameleon_change_m_idx = 0;
2777
2778                 /* Paranoia */
2779                 if (!r_idx) return;
2780         }
2781
2782         m_ptr->r_idx = r_idx;
2783         m_ptr->ap_r_idx = r_idx;
2784         update_mon(m_idx, FALSE);
2785         lite_spot(m_ptr->fy, m_ptr->fx);
2786         if (born)
2787         {
2788                 /* Sub-alignment of a chameleon */
2789                 if (r_ptr->flags3 & (RF3_EVIL | RF3_GOOD))
2790                 {
2791                         m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
2792                         if (r_ptr->flags3 & RF3_EVIL) m_ptr->sub_align |= SUB_ALIGN_EVIL;
2793                         if (r_ptr->flags3 & RF3_GOOD) m_ptr->sub_align |= SUB_ALIGN_GOOD;
2794                 }
2795                 return;
2796         }
2797
2798         if (m_idx == p_ptr->riding)
2799         {
2800                 char m_name[80];
2801                 monster_desc(m_name, m_ptr, 0);
2802 #ifdef JP
2803                 msg_format("ÆÍÁ³%s¤¬ÊÑ¿È¤·¤¿¡£", old_m_name);
2804 #else
2805                 msg_format("Suddenly, %s transforms!", old_m_name);
2806 #endif
2807                 if (!(r_ptr->flags7 & RF7_RIDING))
2808 #ifdef JP
2809                         if (rakuba(0, TRUE)) msg_print("ÃÏÌÌ¤ËÍî¤È¤µ¤ì¤¿¡£");
2810 #else
2811                         if (rakuba(0, TRUE)) msg_format("You have fallen from %s.", m_name);
2812 #endif
2813         }
2814
2815         /* Extract the monster base speed */
2816         m_ptr->mspeed = get_mspeed(r_ptr);
2817
2818         oldmaxhp = m_ptr->max_maxhp;
2819         /* Assign maximal hitpoints */
2820         if (r_ptr->flags1 & RF1_FORCE_MAXHP)
2821         {
2822                 m_ptr->max_maxhp = maxroll(r_ptr->hdice, r_ptr->hside);
2823         }
2824         else
2825         {
2826                 m_ptr->max_maxhp = damroll(r_ptr->hdice, r_ptr->hside);
2827         }
2828         m_ptr->maxhp = (long)(m_ptr->maxhp * m_ptr->max_maxhp) / oldmaxhp;
2829         m_ptr->hp = (long)(m_ptr->hp * m_ptr->max_maxhp) / oldmaxhp;
2830 }
2831
2832
2833 /*
2834  *  Hook for Tanuki
2835  */
2836 static bool monster_hook_tanuki(int r_idx)
2837 {
2838         monster_race *r_ptr = &r_info[r_idx];
2839
2840         if (r_ptr->flags1 & (RF1_UNIQUE)) return FALSE;
2841         if (r_ptr->flags2 & RF2_MULTIPLY) return FALSE;
2842         if (r_ptr->flags7 & (RF7_FRIENDLY | RF7_CHAMELEON)) return FALSE;
2843         if (r_ptr->flags7 & RF7_AQUATIC) return FALSE;
2844
2845         if ((r_ptr->blow[0].method == RBM_EXPLODE) || (r_ptr->blow[1].method == RBM_EXPLODE) || (r_ptr->blow[2].method == RBM_EXPLODE) || (r_ptr->blow[3].method == RBM_EXPLODE))
2846                 return FALSE;
2847
2848         return (*(get_monster_hook()))(r_idx);
2849 }
2850
2851
2852 /*
2853  *  Set initial racial appearance of a monster
2854  */
2855 static int initial_r_appearance(int r_idx)
2856 {
2857         int attempts = 1000;
2858
2859         int ap_r_idx;
2860         int min = MIN(base_level-5, 50);
2861
2862         if (!(r_info[r_idx].flags7 & RF7_TANUKI))
2863                 return r_idx;
2864
2865         get_mon_num_prep(monster_hook_tanuki, NULL);
2866
2867         while (--attempts)
2868         {
2869                 ap_r_idx = get_mon_num(base_level + 10);
2870                 if (r_info[ap_r_idx].level >= min) return ap_r_idx;
2871         }
2872
2873         return r_idx;
2874 }
2875
2876
2877 /*
2878  * Get initial monster speed
2879  */
2880 byte get_mspeed(monster_race *r_ptr)
2881 {
2882         /* Extract the monster base speed */
2883         int mspeed = r_ptr->speed;
2884
2885         /* Hack -- small racial variety */
2886         if (!(r_ptr->flags1 & RF1_UNIQUE) && !p_ptr->inside_arena)
2887         {
2888                 /* Allow some small variation per monster */
2889                 int i = SPEED_TO_ENERGY(r_ptr->speed) / (one_in_(4) ? 3 : 10);
2890                 if (i) mspeed += rand_spread(0, i);
2891         }
2892
2893         if (mspeed > 199) mspeed = 199;
2894
2895         return (byte)mspeed;
2896 }
2897
2898
2899 /*
2900  * Attempt to place a monster of the given race at the given location.
2901  *
2902  * To give the player a sporting chance, any monster that appears in
2903  * line-of-sight and is extremely dangerous can be marked as
2904  * "FORCE_SLEEP", which will cause them to be placed with low energy,
2905  * which often (but not always) lets the player move before they do.
2906  *
2907  * This routine refuses to place out-of-depth "FORCE_DEPTH" monsters.
2908  *
2909  * XXX XXX XXX Use special "here" and "dead" flags for unique monsters,
2910  * remove old "cur_num" and "max_num" fields.
2911  *
2912  * XXX XXX XXX Actually, do something similar for artifacts, to simplify
2913  * the "preserve" mode, and to make the "what artifacts" flag more useful.
2914  *
2915  * This is the only function which may place a monster in the dungeon,
2916  * except for the savefile loading code.
2917  */
2918 static bool place_monster_one(int who, int y, int x, int r_idx, u32b mode)
2919 {
2920         /* Access the location */
2921         cave_type               *c_ptr = &cave[y][x];
2922
2923         monster_type    *m_ptr;
2924
2925         monster_race    *r_ptr = &r_info[r_idx];
2926
2927         cptr            name = (r_name + r_ptr->name);
2928
2929         /* DO NOT PLACE A MONSTER IN THE SMALL SCALE WILDERNESS !!! */
2930         if(p_ptr->wild_mode) return FALSE;
2931
2932         /* Verify location */
2933         if (!in_bounds(y, x)) return (FALSE);
2934
2935         /* Require empty space (if not ghostly) */
2936         if (!(!dun_level && (c_ptr->feat == FEAT_MOUNTAIN) && ((r_ptr->flags8 & RF8_WILD_MOUNTAIN) || (r_ptr->flags7 & RF7_CAN_FLY))) &&
2937             !(cave_empty_bold2(y, x) || (mode & PM_IGNORE_TERRAIN)) &&
2938             !((r_ptr->flags2 & RF2_PASS_WALL) &&
2939               !(cave_perma_bold(y, x) || c_ptr->m_idx ||
2940             player_bold(y, x)))) return (FALSE);
2941
2942         /* Paranoia */
2943         if (!r_idx) return (FALSE);
2944
2945         /* Paranoia */
2946         if (!r_ptr->name) return (FALSE);
2947
2948         /* Nor on the Pattern */
2949         if ((c_ptr->feat >= FEAT_PATTERN_START)
2950          && (c_ptr->feat <= FEAT_PATTERN_XTRA2))
2951                 return (FALSE);
2952
2953         if (!(mode & PM_IGNORE_TERRAIN) &&
2954             !monster_can_cross_terrain(c_ptr->feat, r_ptr))
2955         {
2956                 return FALSE;
2957         }
2958
2959         if (!p_ptr->inside_battle)
2960         {
2961                 /* Hack -- "unique" monsters must be "unique" */
2962                 if (((r_ptr->flags1 & (RF1_UNIQUE)) ||
2963                      (r_ptr->flags7 & (RF7_NAZGUL))) &&
2964                     (r_ptr->cur_num >= r_ptr->max_num))
2965                 {
2966                         /* Cannot create */
2967                         return (FALSE);
2968                 }
2969
2970                 if ((r_ptr->flags7 & (RF7_UNIQUE2)) &&
2971                     (r_ptr->cur_num >= 1))
2972                 {
2973                         return (FALSE);
2974                 }
2975
2976                 if (r_idx == MON_BANORLUPART)
2977                 {
2978                         if (r_info[MON_BANOR].cur_num > 0) return FALSE;
2979                         if (r_info[MON_LUPART].cur_num > 0) return FALSE;
2980                 }
2981
2982                 /* Depth monsters may NOT be created out of depth, unless in Nightmare mode */
2983                 if ((r_ptr->flags1 & (RF1_FORCE_DEPTH)) && (dun_level < r_ptr->level) &&
2984                     (!ironman_nightmare || (r_ptr->flags1 & (RF1_QUESTOR))))
2985                 {
2986                         /* Cannot create */
2987                         return (FALSE);
2988                 }
2989         }
2990
2991         if (quest_number(dun_level))
2992         {
2993                 int hoge = quest_number(dun_level);
2994                 if ((quest[hoge].type == QUEST_TYPE_KILL_LEVEL) || (quest[hoge].type == QUEST_TYPE_RANDOM))
2995                 {
2996                         if(r_idx == quest[hoge].r_idx)
2997                         {
2998                                 int number_mon, i2, j2;
2999                                 number_mon = 0;
3000
3001                                 /* Count all quest monsters */
3002                                 for (i2 = 0; i2 < cur_wid; ++i2)
3003                                         for (j2 = 0; j2 < cur_hgt; j2++)
3004                                                 if (cave[j2][i2].m_idx > 0)
3005                                                         if (m_list[cave[j2][i2].m_idx].r_idx == quest[hoge].r_idx)
3006                                                                 number_mon++;
3007                                 if(number_mon + quest[hoge].cur_num >= quest[hoge].max_num)
3008                                         return FALSE;
3009                         }
3010                 }
3011         }
3012
3013         if (is_glyph_grid(c_ptr))
3014         {
3015                 if (randint1(BREAK_GLYPH) < (r_ptr->level+20))
3016                 {
3017                         /* Describe observable breakage */
3018                         if (c_ptr->info & CAVE_MARK)
3019                         {
3020 #ifdef JP
3021 msg_print("¼é¤ê¤Î¥ë¡¼¥ó¤¬²õ¤ì¤¿¡ª");
3022 #else
3023                                 msg_print("The rune of protection is broken!");
3024 #endif
3025
3026                         }
3027
3028                         /* Forget the rune */
3029                         c_ptr->info &= ~(CAVE_MARK);
3030
3031                         /* Break the rune */
3032                         c_ptr->info &= ~(CAVE_OBJECT);
3033                         c_ptr->mimic = 0;
3034
3035                         /* Notice */
3036                         note_spot(y, x);
3037                 }
3038                 else return FALSE;
3039         }
3040
3041         /* Powerful monster */
3042         if (r_ptr->level > dun_level)
3043         {
3044                 /* Unique monsters */
3045                 if (r_ptr->flags1 & (RF1_UNIQUE))
3046                 {
3047                         /* Message for cheaters */
3048 #ifdef JP
3049                         if (cheat_hear) msg_format("¿¼ÁØ¤Î¥æ¥Ë¡¼¥¯¡¦¥â¥ó¥¹¥¿¡¼ (%s)¡£", name);
3050 #else
3051                         if (cheat_hear) msg_format("Deep Unique (%s).", name);
3052 #endif
3053
3054
3055                         /* Boost rating by twice delta-depth */
3056                         rating += (r_ptr->level - dun_level) * 2;
3057                 }
3058
3059                 /* Normal monsters */
3060                 else
3061                 {
3062                         /* Message for cheaters */
3063 #ifdef JP
3064                         if (cheat_hear) msg_format("¿¼ÁØ¤Î¥â¥ó¥¹¥¿¡¼ (%s)¡£", name);
3065 #else
3066                         if (cheat_hear) msg_format("Deep Monster (%s).", name);
3067 #endif
3068
3069
3070                         /* Boost rating by delta-depth */
3071                         rating += (r_ptr->level - dun_level);
3072                 }
3073         }
3074
3075         /* Note the monster */
3076         else if (r_ptr->flags1 & (RF1_UNIQUE))
3077         {
3078                 /* Unique monsters induce message */
3079 #ifdef JP
3080                 if (cheat_hear) msg_format("¥æ¥Ë¡¼¥¯¡¦¥â¥ó¥¹¥¿¡¼ (%s)¡£", name);
3081 #else
3082                 if (cheat_hear) msg_format("Unique (%s).", name);
3083 #endif
3084
3085         }
3086
3087         if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL) || (r_ptr->level < 10)) mode &= ~PM_KAGE;
3088
3089         /* Make a new monster */
3090         c_ptr->m_idx = m_pop();
3091         hack_m_idx_ii = c_ptr->m_idx;
3092
3093         /* Mega-Hack -- catch "failure" */
3094         if (!c_ptr->m_idx) return (FALSE);
3095
3096
3097         /* Get a new monster record */
3098         m_ptr = &m_list[c_ptr->m_idx];
3099
3100         /* Save the race */
3101         m_ptr->r_idx = r_idx;
3102         m_ptr->ap_r_idx = initial_r_appearance(r_idx);
3103
3104         /* Sub-alignment of a monster */
3105         if ((who > 0) && !(r_ptr->flags3 & (RF3_EVIL | RF3_GOOD)))
3106                 m_ptr->sub_align = m_list[who].sub_align;
3107         else
3108         {
3109                 m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
3110                 if (r_ptr->flags3 & RF3_EVIL) m_ptr->sub_align |= SUB_ALIGN_EVIL;
3111                 if (r_ptr->flags3 & RF3_GOOD) m_ptr->sub_align |= SUB_ALIGN_GOOD;
3112         }
3113
3114         /* Place the monster at the location */
3115         m_ptr->fy = y;
3116         m_ptr->fx = x;
3117
3118
3119         /* No "damage" yet */
3120         m_ptr->stunned = 0;
3121         m_ptr->confused = 0;
3122         m_ptr->monfear = 0;
3123
3124         /* Unknown distance */
3125         m_ptr->cdis = 0;
3126
3127         reset_target(m_ptr);
3128
3129         m_ptr->nickname = 0;
3130
3131         m_ptr->exp = 0;
3132
3133         /* No flags */
3134         m_ptr->mflag = 0;
3135         m_ptr->mflag2 = 0;
3136
3137
3138         /* Your pet summons its pet. */
3139         if (who > 0 && is_pet(&m_list[who]))
3140         {
3141                 mode |= PM_FORCE_PET;
3142                 m_ptr->parent_m_idx = who;
3143         }
3144         else
3145         {
3146                 m_ptr->parent_m_idx = 0;
3147         }
3148
3149         if (r_ptr->flags7 & RF7_CHAMELEON)
3150         {
3151                 choose_new_monster(c_ptr->m_idx, TRUE, 0);
3152                 r_ptr = &r_info[m_ptr->r_idx];
3153                 m_ptr->mflag2 |= MFLAG2_CHAMELEON;
3154                 rating++;
3155
3156                 /* Hack - Set sub_align to neutral when the Chameleon Lord is generated as "GUARDIAN" */
3157                 if ((r_ptr->flags1 & RF1_UNIQUE) && (who <= 0))
3158                         m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
3159         }
3160         else if ((mode & PM_KAGE) && !(mode & PM_FORCE_PET))
3161         {
3162                 m_ptr->ap_r_idx = MON_KAGE;
3163                 m_ptr->mflag2 |= MFLAG2_KAGE;
3164         }
3165
3166         if (mode & PM_NO_PET) m_ptr->mflag2 |= MFLAG2_NOPET;
3167
3168         /* Not visible */
3169         m_ptr->ml = FALSE;
3170
3171         /* Pet? */
3172         if (mode & PM_FORCE_PET)
3173         {
3174                 set_pet(m_ptr);
3175         }
3176         /* Friendly? */
3177         else if ((r_ptr->flags7 & RF7_FRIENDLY) ||
3178                  (mode & PM_FORCE_FRIENDLY) || is_friendly_idx(who))
3179         {
3180                 if (!monster_has_hostile_align(NULL, 0, -1, r_ptr)) set_friendly(m_ptr);
3181         }
3182
3183         /* Assume no sleeping */
3184         m_ptr->csleep = 0;
3185
3186         /* Enforce sleeping if needed */
3187         if ((mode & PM_ALLOW_SLEEP) && r_ptr->sleep && !ironman_nightmare)
3188         {
3189                 int val = r_ptr->sleep;
3190                 m_ptr->csleep = ((val * 2) + randint1(val * 10));
3191         }
3192
3193         /* Assign maximal hitpoints */
3194         if (r_ptr->flags1 & RF1_FORCE_MAXHP)
3195         {
3196                 m_ptr->max_maxhp = maxroll(r_ptr->hdice, r_ptr->hside);
3197         }
3198         else
3199         {
3200                 m_ptr->max_maxhp = damroll(r_ptr->hdice, r_ptr->hside);
3201         }
3202
3203         /* Monsters have double hitpoints in Nightmare mode */
3204         if (ironman_nightmare)
3205         {
3206                 u32b hp = m_ptr->max_maxhp * 2L;
3207
3208                 m_ptr->max_maxhp = (s16b)MIN(30000, hp);
3209         }
3210
3211         m_ptr->maxhp = m_ptr->max_maxhp;
3212
3213         /* And start out fully healthy */
3214         if (m_ptr->r_idx == MON_WOUNDED_BEAR)
3215                 m_ptr->hp = m_ptr->maxhp / 2;
3216         else m_ptr->hp = m_ptr->maxhp;
3217
3218
3219         /* Extract the monster base speed */
3220         m_ptr->mspeed = get_mspeed(r_ptr);
3221
3222         if (mode & PM_HASTE) m_ptr->fast = 100;
3223
3224         /* Give a random starting energy */
3225         if (!ironman_nightmare)
3226         {
3227                 m_ptr->energy_need = ENERGY_NEED() - (s16b)randint0(100);
3228         }
3229         else
3230         {
3231                 /* Nightmare monsters are more prepared */
3232                 m_ptr->energy_need = ENERGY_NEED() - (s16b)randint0(100) * 2;
3233         }
3234
3235         /* Force monster to wait for player, unless in Nightmare mode */
3236         if ((r_ptr->flags1 & RF1_FORCE_SLEEP) && !ironman_nightmare)
3237         {
3238                 /* Monster is still being nice */
3239                 m_ptr->mflag |= (MFLAG_NICE);
3240
3241                 /* Must repair monsters */
3242                 repair_monsters = TRUE;
3243         }
3244
3245         /* Hack -- see "process_monsters()" */
3246         if (c_ptr->m_idx < hack_m_idx)
3247         {
3248                 /* Monster is still being born */
3249                 m_ptr->mflag |= (MFLAG_BORN);
3250         }
3251
3252
3253         if (r_ptr->flags7 & RF7_SELF_LD_MASK)
3254                 p_ptr->update |= (PU_MON_LITE);
3255         else if ((r_ptr->flags7 & RF7_HAS_LD_MASK) && !m_ptr->csleep)
3256                 p_ptr->update |= (PU_MON_LITE);
3257
3258         /* Update the monster */
3259         update_mon(c_ptr->m_idx, TRUE);
3260
3261
3262         /* Count the monsters on the level */
3263         real_r_ptr(m_ptr)->cur_num++;
3264
3265         /*
3266          * Memorize location of the unique monster in saved floors.
3267          * A unique monster move from old saved floor.
3268          */
3269         if (character_dungeon &&
3270             ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)))
3271                 real_r_ptr(m_ptr)->floor_id = p_ptr->floor_id;
3272
3273         /* Hack -- Count the number of "reproducers" */
3274         if (r_ptr->flags2 & RF2_MULTIPLY) num_repro++;
3275
3276
3277         /* Hack -- Notice new multi-hued monsters */
3278         {
3279                 monster_race *ap_r_ptr = &r_info[m_ptr->ap_r_idx];
3280                 if (ap_r_ptr->flags1 & (RF1_ATTR_MULTI | RF1_SHAPECHANGER))
3281                         shimmer_monsters = TRUE;
3282         }
3283
3284         if (p_ptr->warning && character_dungeon)
3285         {
3286                 if (r_ptr->flags1 & RF1_UNIQUE)
3287                 {
3288                         cptr color;
3289                         object_type *o_ptr;
3290                         char o_name[MAX_NLEN];
3291
3292                         if (r_ptr->level > p_ptr->lev + 30)
3293 #ifdef JP
3294                                 color = "¹õ¤¯";
3295 #else
3296                                 color = "black";
3297 #endif
3298                         else if (r_ptr->level > p_ptr->lev + 15)
3299 #ifdef JP
3300                                 color = "»ç¿§¤Ë";
3301 #else
3302                                 color = "purple";
3303 #endif
3304                         else if (r_ptr->level > p_ptr->lev + 5)
3305 #ifdef JP
3306                                 color = "¥ë¥Ó¡¼¿§¤Ë";
3307 #else
3308                                 color = "deep red";
3309 #endif
3310                         else if (r_ptr->level > p_ptr->lev - 5)
3311 #ifdef JP
3312                                 color = "ÀÖ¤¯";
3313 #else
3314                                 color = "red";
3315 #endif
3316                         else if (r_ptr->level > p_ptr->lev - 15)
3317 #ifdef JP
3318                                 color = "¥Ô¥ó¥¯¿§¤Ë";
3319 #else
3320                                 color = "pink";
3321 #endif
3322                         else
3323 #ifdef JP
3324                                 color = "Çò¤¯";
3325 #else
3326                                 color = "white";
3327 #endif
3328
3329                         o_ptr = choose_warning_item();
3330                         if (o_ptr)
3331                         {
3332                                 object_desc(o_name, o_ptr, FALSE, 0);
3333 #ifdef JP
3334                                 msg_format("%s¤Ï%s¸÷¤Ã¤¿¡£", o_name, color);
3335 #else
3336                                 msg_format("%s glows %s.", o_name, color);
3337 #endif
3338                         }
3339                         else
3340                         {
3341 #ifdef JP
3342                                 msg_format("s%¸÷¤ëÊª¤¬Æ¬¤ËÉâ¤«¤ó¤À¡£", color);
3343 #else
3344                                 msg_format("An %s image forms in your mind.");
3345 #endif
3346                         }
3347                 }
3348         }
3349
3350         if (is_explosive_rune_grid(c_ptr))
3351         {
3352                 /* Break the ward */
3353                 if (randint1(BREAK_MINOR_GLYPH) > r_ptr->level)
3354                 {
3355                         /* Describe observable breakage */
3356                         if (c_ptr->info & CAVE_MARK)
3357                         {
3358 #ifdef JP
3359 msg_print("¥ë¡¼¥ó¤¬ÇúÈ¯¤·¤¿¡ª");
3360 #else
3361                                 msg_print("The rune explodes!");
3362 #endif
3363
3364                                 project(0, 2, y, x, 2 * (p_ptr->lev + damroll(7, 7)), GF_MANA, (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI), -1);
3365                         }
3366                 }
3367                 else
3368                 {
3369 #ifdef JP
3370 msg_print("ÇúÈ¯¤Î¥ë¡¼¥ó¤Ï²ò½ü¤µ¤ì¤¿¡£");
3371 #else
3372                         msg_print("An explosive rune was disarmed.");
3373 #endif
3374                 }
3375
3376                 /* Forget the rune */
3377                 c_ptr->info &= ~(CAVE_MARK);
3378
3379                 /* Break the rune */
3380                 c_ptr->info &= ~(CAVE_OBJECT);
3381                 c_ptr->mimic = 0;
3382
3383                 note_spot(y, x);
3384                 lite_spot(y, x);
3385         }
3386
3387         /* Success */
3388         return (TRUE);
3389 }
3390
3391
3392 /*
3393  *  improved version of scatter() for place monster
3394  */
3395
3396 #define MON_SCAT_MAXD 10
3397
3398 static bool mon_scatter(int *yp, int *xp, int y, int x, int max_dist)
3399 {
3400         int place_x[MON_SCAT_MAXD];
3401         int place_y[MON_SCAT_MAXD];
3402         int num[MON_SCAT_MAXD];
3403         int i;
3404         int nx, ny;
3405
3406         if (max_dist >= MON_SCAT_MAXD)
3407                 return FALSE;
3408
3409         for (i = 0; i < MON_SCAT_MAXD; i++)
3410                 num[i] = 0;
3411
3412         for (nx = x - max_dist; nx <= x + max_dist; nx++)
3413                 for (ny = y - max_dist; ny <= y + max_dist; ny++)
3414                 {
3415                         /* Ignore annoying locations */
3416                         if (!in_bounds(ny, nx)) continue;
3417
3418                         /* Require "line of sight" */
3419                         if (!los(y, x, ny, nx)) continue;
3420
3421                         /* Walls and Monsters block flow */
3422                         if (!cave_empty_bold2(ny, nx)) continue;
3423
3424                         /* ... nor on the Pattern */
3425                         if ((cave[ny][nx].feat >= FEAT_PATTERN_START) &&
3426                             (cave[ny][nx].feat <= FEAT_PATTERN_XTRA2))
3427                                 continue;
3428
3429                         i = distance(y, x, ny, nx);
3430
3431                         if (i > max_dist)
3432                                 continue;
3433
3434                         num[i]++;
3435
3436                         /* random swap */
3437                         if(one_in_(num[i]))
3438                         {
3439                                 place_x[i] = nx;
3440                                 place_y[i] = ny;
3441                         }
3442                 }
3443
3444         i = 0;
3445         while (i < MON_SCAT_MAXD && 0 == num[i])
3446                 i++;
3447         if (i >= MON_SCAT_MAXD)
3448                 return FALSE;
3449
3450         *xp = place_x[i];
3451         *yp = place_y[i];
3452
3453         return TRUE;
3454 }
3455
3456
3457 /*
3458  * Maximum size of a group of monsters
3459  */
3460 #define GROUP_MAX       32
3461
3462
3463 /*
3464  * Attempt to place a "group" of monsters around the given location
3465  */
3466 static bool place_monster_group(int who, int y, int x, int r_idx, u32b mode)
3467 {
3468         monster_race *r_ptr = &r_info[r_idx];
3469
3470         int old, n, i;
3471         int total = 0, extra = 0;
3472
3473         int hack_n = 0;
3474
3475         byte hack_y[GROUP_MAX];
3476         byte hack_x[GROUP_MAX];
3477
3478
3479         /* Pick a group size */
3480         total = randint1(10);
3481
3482         /* Hard monsters, small groups */
3483         if (r_ptr->level > dun_level)
3484         {
3485                 extra = r_ptr->level - dun_level;
3486                 extra = 0 - randint1(extra);
3487         }
3488
3489         /* Easy monsters, large groups */
3490         else if (r_ptr->level < dun_level)
3491         {
3492                 extra = dun_level - r_ptr->level;
3493                 extra = randint1(extra);
3494         }
3495
3496         /* Hack -- limit group reduction */
3497         if (extra > 9) extra = 9;
3498
3499         /* Modify the group size */
3500         total += extra;
3501
3502         /* Minimum size */
3503         if (total < 1) total = 1;
3504
3505         /* Maximum size */
3506         if (total > GROUP_MAX) total = GROUP_MAX;
3507
3508
3509         /* Save the rating */
3510         old = rating;
3511
3512         /* Start on the monster */
3513         hack_n = 1;
3514         hack_x[0] = x;
3515         hack_y[0] = y;
3516
3517         /* Puddle monsters, breadth first, up to total */
3518         for (n = 0; (n < hack_n) && (hack_n < total); n++)
3519         {
3520                 /* Grab the location */
3521                 int hx = hack_x[n];
3522                 int hy = hack_y[n];
3523
3524                 /* Check each direction, up to total */
3525                 for (i = 0; (i < 8) && (hack_n < total); i++)
3526                 {
3527                         int mx, my;
3528
3529                         scatter(&my, &mx, hy, hx, 4, 0);
3530
3531                         /* Walls and Monsters block flow */
3532                         if (!cave_empty_bold2(my, mx)) continue;
3533
3534                         /* Attempt to place another monster */
3535                         if (place_monster_one(who, my, mx, r_idx, mode))
3536                         {
3537                                 /* Add it to the "hack" set */
3538                                 hack_y[hack_n] = my;
3539                                 hack_x[hack_n] = mx;
3540                                 hack_n++;
3541                         }
3542                 }
3543         }
3544
3545         /* Hack -- restore the rating */
3546         rating = old;
3547
3548
3549         /* Success */
3550         return (TRUE);
3551 }
3552
3553
3554 /*
3555  * Hack -- help pick an escort type
3556  */
3557 static int place_monster_idx = 0;
3558 static int place_monster_m_idx = 0;
3559
3560 /*
3561  * Hack -- help pick an escort type
3562  */
3563 static bool place_monster_okay(int r_idx)
3564 {
3565         monster_race *r_ptr = &r_info[place_monster_idx];
3566         monster_type *m_ptr = &m_list[place_monster_m_idx];
3567
3568         monster_race *z_ptr = &r_info[r_idx];
3569
3570         /* Hack - Escorts have to have the same dungeon flag */
3571         if (mon_hook_dungeon(place_monster_idx) != mon_hook_dungeon(r_idx)) return (FALSE);
3572
3573         /* Require similar "race" */
3574         if (z_ptr->d_char != r_ptr->d_char) return (FALSE);
3575
3576         /* Skip more advanced monsters */
3577         if (z_ptr->level > r_ptr->level) return (FALSE);
3578
3579         /* Skip unique monsters */
3580         if (z_ptr->flags1 & RF1_UNIQUE) return (FALSE);
3581
3582         /* Paranoia -- Skip identical monsters */
3583         if (place_monster_idx == r_idx) return (FALSE);
3584
3585         /* Skip different alignment */
3586         if (monster_has_hostile_align(m_ptr, 0, 0, z_ptr)) return FALSE;
3587
3588         if (r_ptr->flags7 & RF7_FRIENDLY)
3589         {
3590                 if (monster_has_hostile_align(NULL, 1, -1, z_ptr)) return FALSE;
3591         }
3592
3593         if ((r_ptr->flags7 & RF7_CHAMELEON) && !(z_ptr->flags7 & RF7_CHAMELEON))
3594                 return FALSE;
3595
3596         /* Okay */
3597         return (TRUE);
3598 }
3599
3600
3601 /*
3602  * Attempt to place a monster of the given race at the given location
3603  *
3604  * Note that certain monsters are now marked as requiring "friends".
3605  * These monsters, if successfully placed, and if the "grp" parameter
3606  * is TRUE, will be surrounded by a "group" of identical monsters.
3607  *
3608  * Note that certain monsters are now marked as requiring an "escort",
3609  * which is a collection of monsters with similar "race" but lower level.
3610  *
3611  * Some monsters induce a fake "group" flag on their escorts.
3612  *
3613  * Note the "bizarre" use of non-recursion to prevent annoying output
3614  * when running a code profiler.
3615  *
3616  * Note the use of the new "monster allocation table" code to restrict
3617  * the "get_mon_num()" function to "legal" escort types.
3618  */
3619 bool place_monster_aux(int who, int y, int x, int r_idx, u32b mode)
3620 {
3621         int             i;
3622         monster_race    *r_ptr = &r_info[r_idx];
3623
3624         if (!(mode & PM_NO_KAGE) && one_in_(333))
3625                 mode |= PM_KAGE;
3626
3627         /* Place one monster, or fail */
3628         if (!place_monster_one(who, y, x, r_idx, mode)) return (FALSE);
3629
3630
3631         /* Require the "group" flag */
3632         if (!(mode & PM_ALLOW_GROUP)) return (TRUE);
3633
3634         place_monster_m_idx = hack_m_idx_ii;
3635
3636         /* Friends for certain monsters */
3637         if (r_ptr->flags1 & (RF1_FRIENDS))
3638         {
3639                 /* Attempt to place a group */
3640                 (void)place_monster_group(who, y, x, r_idx, mode);
3641         }
3642
3643
3644         /* Escorts for certain monsters */
3645         if (r_ptr->flags1 & (RF1_ESCORT))
3646         {
3647                 /* Set the escort index */
3648                 place_monster_idx = r_idx;
3649
3650                 /* Try to place several "escorts" */
3651                 for (i = 0; i < 32; i++)
3652                 {
3653                         int nx, ny, z, d = 3;
3654
3655                         /* Pick a location */
3656                         scatter(&ny, &nx, y, x, d, 0);
3657
3658                         /* Require empty grids */
3659                         if (!cave_empty_bold2(ny, nx)) continue;
3660
3661                         /* Prepare allocation table */
3662                         get_mon_num_prep(place_monster_okay, get_monster_hook2(ny, nx));
3663
3664                         /* Pick a random race */
3665                         z = get_mon_num(r_ptr->level);
3666
3667                         /* Handle failure */
3668                         if (!z) break;
3669
3670                         /* Place a single escort */
3671                         (void)place_monster_one(place_monster_m_idx, ny, nx, z, mode);
3672
3673                         /* Place a "group" of escorts if needed */
3674                         if ((r_info[z].flags1 & RF1_FRIENDS) ||
3675                             (r_ptr->flags1 & RF1_ESCORTS))
3676                         {
3677                                 /* Place a group of monsters */
3678                                 (void)place_monster_group(place_monster_m_idx, ny, nx, z, mode);
3679                         }
3680                 }
3681         }
3682
3683         /* Success */
3684         return (TRUE);
3685 }
3686
3687
3688 /*
3689  * Hack -- attempt to place a monster at the given location
3690  *
3691  * Attempt to find a monster appropriate to the "monster_level"
3692  */
3693 bool place_monster(int y, int x, u32b mode)
3694 {
3695         int r_idx;
3696
3697         /* Prepare allocation table */
3698         get_mon_num_prep(get_monster_hook(), get_monster_hook2(y, x));
3699
3700         /* Pick a monster */
3701         r_idx = get_mon_num(monster_level);
3702
3703         /* Handle failure */
3704         if (!r_idx) return (FALSE);
3705
3706         /* Attempt to place the monster */
3707         if (place_monster_aux(0, y, x, r_idx, mode)) return (TRUE);
3708
3709         /* Oops */
3710         return (FALSE);
3711 }
3712
3713
3714 #ifdef MONSTER_HORDES
3715
3716 bool alloc_horde(int y, int x)
3717 {
3718         monster_race *r_ptr = NULL;
3719         int r_idx = 0;
3720         int m_idx;
3721         int attempts = 1000;
3722         int cy = y;
3723         int cx = x;
3724
3725         /* Prepare allocation table */
3726         get_mon_num_prep(get_monster_hook(), get_monster_hook2(y, x));
3727
3728         while (--attempts)
3729         {
3730                 /* Pick a monster */
3731                 r_idx = get_mon_num(monster_level);
3732
3733                 /* Handle failure */
3734                 if (!r_idx) return (FALSE);
3735
3736                 r_ptr = &r_info[r_idx];
3737
3738                 if (r_ptr->flags1 & RF1_UNIQUE) continue;
3739
3740                 if (r_idx == MON_HAGURE) continue;
3741                 break;
3742         }
3743         if (attempts < 1) return FALSE;
3744
3745         attempts = 1000;
3746
3747         while (--attempts)
3748         {
3749                 /* Attempt to place the monster */
3750                 if (place_monster_aux(0, y, x, r_idx, 0L)) break;
3751         }
3752
3753         if (attempts < 1) return FALSE;
3754
3755         m_idx = cave[y][x].m_idx;
3756
3757         if (m_list[m_idx].mflag2 & MFLAG2_CHAMELEON) r_ptr = &r_info[m_list[m_idx].r_idx];
3758         summon_kin_type = r_ptr->d_char;
3759
3760         for (attempts = randint1(10) + 5; attempts; attempts--)
3761         {
3762                 scatter(&cy, &cx, y, x, 5, 0);
3763
3764                 (void)summon_specific(m_idx, cy, cx, dun_level + 5, SUMMON_KIN, PM_ALLOW_GROUP);
3765
3766                 y = cy;
3767                 x = cx;
3768         }
3769
3770         return TRUE;
3771 }
3772
3773 #endif /* MONSTER_HORDES */
3774
3775
3776 /*
3777  * Put the Guardian
3778  */
3779 bool alloc_guardian(void)
3780 {
3781         int guardian = d_info[dungeon_type].final_guardian;
3782
3783         if (guardian && (d_info[dungeon_type].maxdepth == dun_level) && (r_info[guardian].cur_num < r_info[guardian].max_num))
3784         {
3785                 int oy;
3786                 int ox;
3787                 int try = 4000;
3788
3789                 /* Find a good position */
3790                 while (try)
3791                 {
3792                         /* Get a random spot */
3793                         oy = randint1(cur_hgt - 4) + 2;
3794                         ox = randint1(cur_wid - 4) + 2;
3795
3796                         /* Is it a good spot ? */
3797                         if (cave_empty_bold2(oy, ox) && monster_can_cross_terrain(cave[oy][ox].feat, &r_info[guardian]))
3798                         {
3799                                 /* Place the guardian */
3800                                 if (place_monster_aux(0, oy, ox, guardian, (PM_ALLOW_GROUP | PM_NO_KAGE | PM_NO_PET))) return TRUE;
3801                         }
3802
3803                         /* One less try */
3804                         try--;
3805                 }
3806         }
3807
3808         return FALSE;
3809 }
3810
3811
3812 /*
3813  * Attempt to allocate a random monster in the dungeon.
3814  *
3815  * Place the monster at least "dis" distance from the player.
3816  *
3817  * Use "slp" to choose the initial "sleep" status
3818  *
3819  * Use "monster_level" for the monster level
3820  */
3821 bool alloc_monster(int dis, u32b mode)
3822 {
3823         int                     y = 0, x = 0;
3824         int         attempts_left = 10000;
3825
3826         /* Put the Guardian */
3827         if (alloc_guardian()) return TRUE;
3828
3829         /* Find a legal, distant, unoccupied, space */
3830         while (attempts_left--)
3831         {
3832                 /* Pick a location */
3833                 y = randint0(cur_hgt);
3834                 x = randint0(cur_wid);
3835
3836                 /* Require empty floor grid (was "naked") */
3837                 if (dun_level || (wilderness[p_ptr->wilderness_y][p_ptr->wilderness_x].terrain != TERRAIN_MOUNTAIN))
3838                 {
3839                         if (!cave_empty_bold2(y, x)) continue;
3840                 }
3841                 else
3842                 {
3843                         if (!cave_empty_bold2(y, x) && (cave[y][x].feat != FEAT_MOUNTAIN)) continue;
3844                 }
3845
3846                 /* Accept far away grids */
3847                 if (distance(y, x, py, px) > dis) break;
3848         }
3849
3850         if (!attempts_left)
3851         {
3852                 if (cheat_xtra || cheat_hear)
3853                 {
3854 #ifdef JP
3855 msg_print("·Ù¹ð¡ª¿·¤¿¤Ê¥â¥ó¥¹¥¿¡¼¤òÇÛÃÖ¤Ç¤¤Þ¤»¤ó¡£¾®¤µ¤¤³¬¤Ç¤¹¤«¡©");
3856 #else
3857                         msg_print("Warning! Could not allocate a new monster. Small level?");
3858 #endif
3859
3860                 }
3861
3862                 return (FALSE);
3863         }
3864
3865
3866 #ifdef MONSTER_HORDES
3867         if (randint1(5000) <= dun_level)
3868         {
3869                 if (alloc_horde(y, x))
3870                 {
3871 #ifdef JP
3872                         if (cheat_hear) msg_format("¥â¥ó¥¹¥¿¡¼¤ÎÂç·²(%c)", summon_kin_type);
3873 #else
3874                         if (cheat_hear) msg_format("Monster horde (%c).", summon_kin_type);
3875 #endif
3876
3877                         return (TRUE);
3878                 }
3879         }
3880         else
3881         {
3882 #endif /* MONSTER_HORDES */
3883
3884                 /* Attempt to place the monster, allow groups */
3885                 if (place_monster(y, x, (mode | PM_ALLOW_GROUP))) return (TRUE);
3886
3887 #ifdef MONSTER_HORDES
3888         }
3889 #endif /* MONSTER_HORDES */
3890
3891         /* Nope */
3892         return (FALSE);
3893 }
3894
3895
3896
3897
3898 /*
3899  * Hack -- help decide if a monster race is "okay" to summon
3900  */
3901 static bool summon_specific_okay(int r_idx)
3902 {
3903         monster_race *r_ptr = &r_info[r_idx];
3904
3905         /* Hack - Only summon dungeon monsters */
3906         if (!mon_hook_dungeon(r_idx)) return (FALSE);
3907
3908         /* Hack -- identify the summoning monster */
3909         if (summon_specific_who > 0)
3910         {
3911                 monster_type *m_ptr = &m_list[summon_specific_who];
3912
3913                 /* Do not summon enemies */
3914
3915                 /* Friendly vs. opposite aligned normal or pet */
3916                 if (monster_has_hostile_align(m_ptr, 0, 0, r_ptr)) return FALSE;
3917         }
3918         /* Use the player's alignment */
3919         else if (summon_specific_who < 0)
3920         {
3921                 /* Do not summon enemies of the pets */
3922                 if (monster_has_hostile_align(NULL, 10, -10, r_ptr))
3923                 {
3924                         if (!one_in_(ABS(p_ptr->align) / 2 + 1)) return FALSE;
3925                 }
3926         }
3927
3928         /* Hack -- no specific type specified */
3929         if (!summon_specific_type) return (TRUE);
3930
3931         if (!summon_unique_okay && ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))) return FALSE;
3932
3933         if ((summon_specific_who < 0) &&
3934             ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)) &&
3935             monster_has_hostile_align(NULL, 10, -10, r_ptr))
3936                 return FALSE;
3937
3938         if ((r_ptr->flags7 & RF7_CHAMELEON) && (d_info[dungeon_type].flags1 & DF1_CHAMELEON)) return TRUE;
3939
3940         return (summon_specific_aux(r_idx));
3941 }
3942
3943
3944 /*
3945  * Place a monster (of the specified "type") near the given
3946  * location.  Return TRUE if a monster was actually summoned.
3947  *
3948  * We will attempt to place the monster up to 10 times before giving up.
3949  *
3950  * Note: SUMMON_UNIQUE and SUMMON_AMBERITES will summon Unique's
3951  * Note: SUMMON_HI_UNDEAD and SUMMON_HI_DRAGON may summon Unique's
3952  * Note: None of the other summon codes will ever summon Unique's.
3953  *
3954  * This function has been changed.  We now take the "monster level"
3955  * of the summoning monster as a parameter, and use that, along with
3956  * the current dungeon level, to help determine the level of the
3957  * desired monster.  Note that this is an upper bound, and also
3958  * tends to "prefer" monsters of that level.  Currently, we use
3959  * the average of the dungeon and monster levels, and then add
3960  * five to allow slight increases in monster power.
3961  *
3962  * Note that we use the new "monster allocation table" creation code
3963  * to restrict the "get_mon_num()" function to the set of "legal"
3964  * monsters, making this function much faster and more reliable.
3965  *
3966  * Note that this function may not succeed, though this is very rare.
3967  */
3968 bool summon_specific(int who, int y1, int x1, int lev, int type, u32b mode)
3969 {
3970         int x, y, r_idx;
3971
3972         if (p_ptr->inside_arena) return (FALSE);
3973
3974         if (!mon_scatter(&y, &x, y1, x1, 2)) return FALSE;
3975
3976         /* Save the summoner */
3977         summon_specific_who = who;
3978
3979         /* Save the "summon" type */
3980         summon_specific_type = type;
3981
3982         summon_unique_okay = (mode & PM_ALLOW_UNIQUE) ? TRUE : FALSE;
3983
3984         /* Prepare allocation table */
3985         get_mon_num_prep(summon_specific_okay, get_monster_hook2(y, x));
3986
3987         /* Pick a monster, using the level calculation */
3988         r_idx = get_mon_num((dun_level + lev) / 2 + 5);
3989
3990         /* Handle failure */
3991         if (!r_idx)
3992         {
3993                 summon_specific_type = 0;
3994                 return (FALSE);
3995         }
3996
3997         if ((type == SUMMON_BLUE_HORROR) || (type == SUMMON_DAWN)) mode |= PM_NO_KAGE;
3998
3999         /* Attempt to place the monster (awake, allow groups) */
4000         if (!place_monster_aux(who, y, x, r_idx, mode))
4001         {
4002                 summon_specific_type = 0;
4003                 return (FALSE);
4004         }
4005
4006         summon_specific_type = 0;
4007         /* Success */
4008         return (TRUE);
4009 }
4010
4011 /* A "dangerous" function, creates a pet of the specified type */
4012 bool summon_named_creature (int who, int oy, int ox, int r_idx, u32b mode)
4013 {
4014         int x, y;
4015
4016         /* Paranoia */
4017         /* if (!r_idx) return; */
4018
4019         /* Prevent illegal monsters */
4020         if (r_idx >= max_r_idx) return FALSE;
4021
4022         if (p_ptr->inside_arena) return FALSE;
4023
4024         if (!mon_scatter(&y, &x, oy, ox, 2)) return FALSE;
4025
4026         /* Place it (allow groups) */
4027         return place_monster_aux(who, y, x, r_idx, (mode | PM_NO_KAGE));
4028 }
4029
4030
4031 /*
4032  * Let the given monster attempt to reproduce.
4033  *
4034  * Note that "reproduction" REQUIRES empty space.
4035  */
4036 bool multiply_monster(int m_idx, bool clone, u32b mode)
4037 {
4038         monster_type    *m_ptr = &m_list[m_idx];
4039
4040         int y, x;
4041
4042         if (!mon_scatter(&y, &x, m_ptr->fy, m_ptr->fx, 1))
4043                 return FALSE;
4044
4045         if (m_ptr->mflag2 & MFLAG2_NOPET) mode |= PM_NO_PET;
4046
4047         /* Create a new monster (awake, no groups) */
4048         if (!place_monster_aux(m_idx, y, x, m_ptr->r_idx, (mode | PM_NO_KAGE)))
4049                 return FALSE;
4050
4051         /* Hack -- Transfer "clone" flag */
4052         if (clone || (m_ptr->smart & SM_CLONED))
4053         {
4054                 m_list[hack_m_idx_ii].smart |= SM_CLONED;
4055                 m_list[hack_m_idx_ii].mflag2 |= MFLAG2_NOPET;
4056         }
4057
4058         /* Hack -- Shadower spawns Shadower */
4059         if (m_ptr->mflag2 & MFLAG2_KAGE) m_list[hack_m_idx_ii].mflag2 |= MFLAG2_KAGE;
4060
4061         /* Hack -- Appearance transfer */
4062         if (!is_original_ap(m_ptr)) m_list[hack_m_idx_ii].ap_r_idx = m_ptr->ap_r_idx;
4063
4064         return TRUE;
4065 }
4066
4067
4068
4069
4070
4071 /*
4072  * Dump a message describing a monster's reaction to damage
4073  *
4074  * Technically should attempt to treat "Beholder"'s as jelly's
4075  */
4076 void message_pain(int m_idx, int dam)
4077 {
4078         long oldhp, newhp, tmp;
4079         int percentage;
4080
4081         monster_type *m_ptr = &m_list[m_idx];
4082         monster_race *r_ptr = &r_info[m_ptr->r_idx];
4083
4084         char m_name[80];
4085
4086
4087         /* Get the monster name */
4088         monster_desc(m_name, m_ptr, 0);
4089
4090         /* Notice non-damage */
4091         if (dam == 0)
4092         {
4093 #ifdef JP
4094                 msg_format("%^s¤Ï¥À¥á¡¼¥¸¤ò¼õ¤±¤Æ¤¤¤Ê¤¤¡£", m_name);
4095 #else
4096                 msg_format("%^s is unharmed.", m_name);
4097 #endif
4098
4099                 return;
4100         }
4101
4102         /* Note -- subtle fix -CFT */
4103         newhp = (long)(m_ptr->hp);
4104         oldhp = newhp + (long)(dam);
4105         tmp = (newhp * 100L) / oldhp;
4106         percentage = (int)(tmp);
4107
4108
4109         /* Mushrooms, Eyes, Jellies, Molds, Vortices, Worms, Quylthulgs */
4110         if (strchr(",ejmvwQ", r_ptr->d_char))
4111         {
4112 #ifdef JP
4113                 if (percentage > 95)
4114                         msg_format("%^s¤Ï¤Û¤È¤ó¤Éµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4115                 else if (percentage > 75)
4116                         msg_format("%^s¤Ï¤·¤ê¹þ¤ß¤·¤¿¡£", m_name);
4117                 else if (percentage > 50)
4118                         msg_format("%^s¤Ï½Ì¤³¤Þ¤Ã¤¿¡£", m_name);
4119                 else if (percentage > 35)
4120                         msg_format("%^s¤ÏÄË¤ß¤Ë¿Ì¤¨¤¿¡£", m_name);
4121                 else if (percentage > 20)
4122                         msg_format("%^s¤Ï¿È¤â¤À¤¨¤·¤¿¡£", m_name);
4123                 else if (percentage > 10)
4124                         msg_format("%^s¤Ï¶ìÄË¤Ç¿È¤â¤À¤¨¤·¤¿¡£", m_name);
4125                 else
4126                         msg_format("%^s¤Ï¤°¤Ë¤ã¤°¤Ë¤ã¤ÈáÛÚ»¤·¤¿¡£", m_name);
4127 #else
4128                 if (percentage > 95)
4129                         msg_format("%^s barely notices.", m_name);
4130                 else if (percentage > 75)
4131                         msg_format("%^s flinches.", m_name);
4132                 else if (percentage > 50)
4133                         msg_format("%^s squelches.", m_name);
4134                 else if (percentage > 35)
4135                         msg_format("%^s quivers in pain.", m_name);
4136                 else if (percentage > 20)
4137                         msg_format("%^s writhes about.", m_name);
4138                 else if (percentage > 10)
4139                         msg_format("%^s writhes in agony.", m_name);
4140                 else
4141                         msg_format("%^s jerks limply.", m_name);
4142 #endif
4143
4144         }
4145
4146
4147         /* Fish */
4148         else if (strchr("l", r_ptr->d_char))
4149         {
4150                 if (percentage > 95)
4151 #ifdef JP
4152 msg_format("%^s¤Ï¤Û¤È¤ó¤Éµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4153 #else
4154                         msg_format("%^s barely notices.", m_name);
4155 #endif
4156                 else if (percentage > 75)
4157 #ifdef JP
4158 msg_format("%^s¤Ï¤·¤ê¹þ¤ß¤·¤¿¡£", m_name);
4159 #else
4160                         msg_format("%^s flinches.", m_name);
4161 #endif
4162                 else if (percentage > 50)
4163 #ifdef JP
4164 msg_format("%^s¤Ïí´í°¤·¤¿¡£", m_name);
4165 #else
4166                         msg_format("%^s hesitates.", m_name);
4167 #endif
4168                 else if (percentage > 35)
4169 #ifdef JP
4170 msg_format("%^s¤ÏÄË¤ß¤Ë¿Ì¤¨¤¿¡£", m_name);
4171 #else
4172                         msg_format("%^s quivers in pain.", m_name);
4173 #endif
4174                 else if (percentage > 20)
4175 #ifdef JP
4176 msg_format("%^s¤Ï¿È¤â¤À¤¨¤·¤¿¡£", m_name);
4177 #else
4178                         msg_format("%^s writhes about.", m_name);
4179 #endif
4180                 else if (percentage > 10)
4181 #ifdef JP
4182 msg_format("%^s¤Ï¶ìÄË¤Ç¿È¤â¤À¤¨¤·¤¿¡£", m_name);
4183 #else
4184                         msg_format("%^s writhes in agony.", m_name);
4185 #endif
4186                 else
4187 #ifdef JP
4188 msg_format("%^s¤Ï¤°¤Ë¤ã¤°¤Ë¤ã¤ÈáÛÚ»¤·¤¿¡£", m_name);
4189 #else
4190                         msg_format("%^s jerks limply.", m_name);
4191 #endif
4192         }
4193
4194
4195         /* Golems, Walls, Doors, Stairs */
4196         else if (strchr("g#+<>", r_ptr->d_char))
4197         {
4198                 if (percentage > 95)
4199 #ifdef JP
4200 msg_format("%s¤Ï¹¶·â¤òµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4201 #else
4202                         msg_format("%^s ignores the attack.", m_name);
4203 #endif
4204                 else if (percentage > 75)
4205 #ifdef JP
4206 msg_format("%s¤Ï¹¶·â¤Ë¸ª¤ò¤¹¤¯¤á¤¿¡£", m_name);
4207 #else
4208                         msg_format("%^s shrugs off the attack.", m_name);
4209 #endif
4210                 else if (percentage > 50)
4211 #ifdef JP
4212 msg_format("%^s¤ÏÍëÌÄ¤Î¤è¤¦¤ËËÊ¤¨¤¿¡£", m_name);
4213 #else
4214                         msg_format("%^s roars thunderously.", m_name);
4215 #endif
4216                 else if (percentage > 35)
4217 #ifdef JP
4218 msg_format("%^s¤Ï¶ì¤·¤²¤ËËÊ¤¨¤¿¡£", m_name);
4219 #else
4220                         msg_format("%^s rumbles.", m_name);
4221 #endif
4222                 else if (percentage > 20)
4223 #ifdef JP
4224 msg_format("%^s¤Ï¤¦¤á¤¤¤¿¡£", m_name);
4225 #else
4226                         msg_format("%^s grunts.", m_name);
4227 #endif
4228                 else if (percentage > 10)
4229 #ifdef JP
4230 msg_format("%^s¤Ïí´í°¤·¤¿¡£", m_name);
4231 #else
4232                         msg_format("%^s hesitates.", m_name);
4233 #endif
4234                 else
4235 #ifdef JP
4236 msg_format("%^s¤Ï¤¯¤·¤ã¤¯¤·¤ã¤Ë¤Ê¤Ã¤¿¡£", m_name);
4237 #else
4238                         msg_format("%^s crumples.", m_name);
4239 #endif
4240         }
4241
4242
4243         /* Snakes, Hydrae, Reptiles, Mimics */
4244         else if (strchr("JMR", r_ptr->d_char) || !isalpha(r_ptr->d_char))
4245         {
4246                 if (percentage > 95)
4247 #ifdef JP
4248 msg_format("%^s¤Ï¤Û¤È¤ó¤Éµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4249 #else
4250                         msg_format("%^s barely notices.", m_name);
4251 #endif
4252                 else if (percentage > 75)
4253 #ifdef JP
4254 msg_format("%^s¤Ï¥·¡¼¥Ã¤ÈÌÄ¤¤¤¿¡£", m_name);
4255 #else
4256                         msg_format("%^s hisses.", m_name);
4257 #endif
4258                 else if (percentage > 50)
4259 #ifdef JP
4260 msg_format("%^s¤ÏÅÜ¤Ã¤ÆÆ¬¤ò¾å¤²¤¿¡£", m_name);
4261 #else
4262                         msg_format("%^s rears up in anger.", m_name);
4263 #endif
4264                 else if (percentage > 35)
4265 #ifdef JP
4266 msg_format("%^s¤ÏÌÔÁ³¤È°Ò³Å¤·¤¿¡£", m_name);
4267 #else
4268                         msg_format("%^s hisses furiously.", m_name);
4269 #endif
4270                 else if (percentage > 20)
4271 #ifdef JP
4272 msg_format("%^s¤Ï¿È¤â¤À¤¨¤·¤¿¡£", m_name);
4273 #else
4274                         msg_format("%^s writhes about.", m_name);
4275 #endif
4276                 else if (percentage > 10)
4277 #ifdef JP
4278 msg_format("%^s¤Ï¶ìÄË¤Ç¿È¤â¤À¤¨¤·¤¿¡£", m_name);
4279 #else
4280                         msg_format("%^s writhes in agony.", m_name);
4281 #endif
4282                 else
4283 #ifdef JP
4284 msg_format("%^s¤Ï¤°¤Ë¤ã¤°¤Ë¤ã¤ÈáÛÚ»¤·¤¿¡£", m_name);
4285 #else
4286                         msg_format("%^s jerks limply.", m_name);
4287 #endif
4288         }
4289
4290
4291         /* Felines */
4292         else if (strchr("f", r_ptr->d_char))
4293         {
4294                 if (percentage > 95)
4295 #ifdef JP
4296 msg_format("%s¤Ï¹¶·â¤Ë¸ª¤ò¤¹¤¯¤á¤¿¡£", m_name);
4297 #else
4298                         msg_format("%^s shrugs off the attack.", m_name);
4299 #endif
4300                 else if (percentage > 75)
4301 #ifdef JP
4302 msg_format("%^s¤ÏËÊ¤¨¤¿¡£", m_name);
4303 #else
4304                         msg_format("%^s roars.", m_name);
4305 #endif
4306                 else if (percentage > 50)
4307 #ifdef JP
4308 msg_format("%^s¤ÏÅÜ¤Ã¤ÆËÊ¤¨¤¿¡£", m_name);
4309 #else
4310                         msg_format("%^s growls angrily.", m_name);
4311 #endif
4312                 else if (percentage > 35)
4313 #ifdef JP
4314 msg_format("%^s¤ÏÄË¤ß¤Ç¥·¡¼¥Ã¤ÈÌÄ¤¤¤¿¡£", m_name);
4315 #else
4316                         msg_format("%^s hisses with pain.", m_name);
4317 #endif
4318                 else if (percentage > 20)
4319 #ifdef JP
4320 msg_format("%^s¤ÏÄË¤ß¤Ç¼å¡¹¤·¤¯ÌÄ¤¤¤¿¡£", m_name);
4321 #else
4322                         msg_format("%^s mewls in pain.", m_name);
4323 #endif
4324                 else if (percentage > 10)
4325 #ifdef JP
4326 msg_format("%^s¤Ï¶ìÄË¤Ë¤¦¤á¤¤¤¿¡£", m_name);
4327 #else
4328                         msg_format("%^s hisses in agony.", m_name);
4329 #endif
4330                 else
4331 #ifdef JP
4332 msg_format("%s¤Ï°¥¤ì¤ÊÌÄ¤À¼¤ò½Ð¤·¤¿¡£", m_name);
4333 #else
4334                         msg_format("%^s mewls pitifully.", m_name);
4335 #endif
4336         }
4337
4338
4339         /* Ants, Centipedes, Flies, Insects, Beetles, Spiders */
4340         else if (strchr("acFIKS", r_ptr->d_char))
4341         {
4342                 if (percentage > 95)
4343 #ifdef JP
4344 msg_format("%s¤Ï¹¶·â¤òµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4345 #else
4346                         msg_format("%^s ignores the attack.", m_name);
4347 #endif
4348                 else if (percentage > 75)
4349 #ifdef JP
4350 msg_format("%^s¤Ï¥¡¼¥¡¼ÌÄ¤¤¤¿¡£", m_name);
4351 #else
4352                         msg_format("%^s chitters.", m_name);
4353 #endif
4354
4355                 else if (percentage > 50)
4356 #ifdef JP
4357 msg_format("%^s¤Ï¥è¥í¥è¥íÆ¨¤²²ó¤Ã¤¿¡£", m_name);
4358 #else
4359                         msg_format("%^s scuttles about.", m_name);
4360 #endif
4361
4362                 else if (percentage > 35)
4363 #ifdef JP
4364 msg_format("%^s¤Ï¤¦¤ë¤µ¤¯ÌÄ¤¤¤¿¡£", m_name);
4365 #else
4366                         msg_format("%^s twitters.", m_name);
4367 #endif
4368
4369                 else if (percentage > 20)
4370 #ifdef JP
4371 msg_format("%^s¤ÏÄË¤ß¤ËáÛÚ»¤·¤¿¡£", m_name);
4372 #else
4373                         msg_format("%^s jerks in pain.", m_name);
4374 #endif
4375
4376                 else if (percentage > 10)
4377 #ifdef JP
4378 msg_format("%^s¤Ï¶ìÄË¤ÇáÛÚ»¤·¤¿¡£", m_name);
4379 #else
4380                         msg_format("%^s jerks in agony.", m_name);
4381 #endif
4382
4383                 else
4384 #ifdef JP
4385 msg_format("%^s¤Ï¥Ô¥¯¥Ô¥¯¤Ò¤¤Ä¤Ã¤¿¡£", m_name);
4386 #else
4387                         msg_format("%^s twitches.", m_name);
4388 #endif
4389
4390         }
4391
4392
4393         /* Birds */
4394         else if (strchr("B", r_ptr->d_char))
4395         {
4396                 if (percentage > 95)
4397 #ifdef JP
4398 msg_format("%^s¤Ï¤µ¤¨¤º¤Ã¤¿¡£", m_name);
4399 #else
4400                         msg_format("%^s chirps.", m_name);
4401 #endif
4402
4403                 else if (percentage > 75)
4404 #ifdef JP
4405 msg_format("%^s¤Ï¥Ô¡¼¥Ô¡¼ÌÄ¤¤¤¿¡£", m_name);
4406 #else
4407                         msg_format("%^s twitters.", m_name);
4408 #endif
4409
4410                 else if (percentage > 50)
4411 #ifdef JP
4412 msg_format("%^s¤Ï¥®¥ã¡¼¥®¥ã¡¼ÌÄ¤¤¤¿¡£", m_name);
4413 #else
4414                         msg_format("%^s squawks.", m_name);
4415 #endif
4416
4417                 else if (percentage > 35)
4418 #ifdef JP
4419 msg_format("%^s¤Ï¥®¥ã¡¼¥®¥ã¡¼ÌÄ¤¤ï¤á¤¤¤¿¡£", m_name);
4420 #else
4421                         msg_format("%^s chatters.", m_name);
4422 #endif
4423
4424                 else if (percentage > 20)
4425 #ifdef JP
4426 msg_format("%^s¤Ï¶ì¤·¤ó¤À¡£", m_name);
4427 #else
4428                         msg_format("%^s jeers.", m_name);
4429 #endif
4430
4431                 else if (percentage > 10)
4432 #ifdef JP
4433 msg_format("%^s¤Ï¤Î¤¿¤¦¤Á²ó¤Ã¤¿¡£", m_name);
4434 #else
4435                         msg_format("%^s flutters about.", m_name);
4436 #endif
4437
4438                 else
4439 #ifdef JP
4440 msg_format("%^s¤Ï¥¡¼¥¡¼¤ÈÌÄ¤¶«¤ó¤À¡£", m_name);
4441 #else
4442                         msg_format("%^s squeaks.", m_name);
4443 #endif
4444
4445         }
4446
4447
4448         /* Dragons, Demons, High Undead */
4449         else if (strchr("duDLUW", r_ptr->d_char))
4450         {
4451                 if (percentage > 95)
4452 #ifdef JP
4453 msg_format("%s¤Ï¹¶·â¤òµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4454 #else
4455                         msg_format("%^s ignores the attack.", m_name);
4456 #endif
4457
4458                 else if (percentage > 75)
4459 #ifdef JP
4460 msg_format("%^s¤Ï¤·¤ê¹þ¤ß¤·¤¿¡£", m_name);
4461 #else
4462                         msg_format("%^s flinches.", m_name);
4463 #endif
4464
4465                 else if (percentage > 50)
4466 #ifdef JP
4467 msg_format("%^s¤ÏÄË¤ß¤Ç¥·¡¼¥Ã¤ÈÌÄ¤¤¤¿¡£", m_name);
4468 #else
4469                         msg_format("%^s hisses in pain.", m_name);
4470 #endif
4471
4472                 else if (percentage > 35)
4473 #ifdef JP
4474 msg_format("%^s¤ÏÄË¤ß¤Ç¤¦¤Ê¤Ã¤¿¡£", m_name);
4475 #else
4476                         msg_format("%^s snarls with pain.", m_name);
4477 #endif
4478
4479                 else if (percentage > 20)
4480 #ifdef JP
4481 msg_format("%^s¤ÏÄË¤ß¤ËËÊ¤¨¤¿¡£", m_name);
4482 #else
4483                         msg_format("%^s roars with pain.", m_name);
4484 #endif
4485
4486                 else if (percentage > 10)
4487 #ifdef JP
4488 msg_format("%^s¤Ï¶ì¤·¤²¤Ë¶«¤ó¤À¡£", m_name);
4489 #else
4490                         msg_format("%^s gasps.", m_name);
4491 #endif
4492
4493                 else
4494 #ifdef JP
4495 msg_format("%^s¤Ï¼å¡¹¤·¤¯¤¦¤Ê¤Ã¤¿¡£", m_name);
4496 #else
4497                         msg_format("%^s snarls feebly.", m_name);
4498 #endif
4499
4500         }
4501
4502
4503         /* Skeletons */
4504         else if (strchr("s", r_ptr->d_char))
4505         {
4506                 if (percentage > 95)
4507 #ifdef JP
4508 msg_format("%s¤Ï¹¶·â¤òµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4509 #else
4510                         msg_format("%^s ignores the attack.", m_name);
4511 #endif
4512
4513                 else if (percentage > 75)
4514 #ifdef JP
4515 msg_format("%s¤Ï¹¶·â¤Ë¸ª¤ò¤¹¤¯¤á¤¿¡£", m_name);
4516 #else
4517                         msg_format("%^s shrugs off the attack.", m_name);
4518 #endif
4519
4520                 else if (percentage > 50)
4521 #ifdef JP
4522 msg_format("%^s¤Ï¥«¥¿¥«¥¿¤È¾Ð¤Ã¤¿¡£", m_name);
4523 #else
4524                         msg_format("%^s rattles.", m_name);
4525 #endif
4526
4527                 else if (percentage > 35)
4528 #ifdef JP
4529 msg_format("%^s¤Ï¤è¤í¤á¤¤¤¿¡£", m_name);
4530 #else
4531                         msg_format("%^s stumbles.", m_name);
4532 #endif
4533
4534                 else if (percentage > 20)
4535 #ifdef JP
4536 msg_format("%^s¤Ï¥«¥¿¥«¥¿¸À¤Ã¤¿¡£", m_name);
4537 #else
4538                         msg_format("%^s rattles.", m_name);
4539 #endif
4540
4541                 else if (percentage > 10)
4542 #ifdef JP
4543 msg_format("%^s¤Ï¤è¤í¤á¤¤¤¿¡£", m_name);
4544 #else
4545                         msg_format("%^s staggers.", m_name);
4546 #endif
4547
4548                 else
4549 #ifdef JP
4550 msg_format("%^s¤Ï¥¬¥¿¥¬¥¿¸À¤Ã¤¿¡£", m_name);
4551 #else
4552                         msg_format("%^s clatters.", m_name);
4553 #endif
4554
4555         }
4556
4557
4558         /* Zombies */
4559         else if (strchr("z", r_ptr->d_char))
4560         {
4561                 if (percentage > 95)
4562 #ifdef JP
4563 msg_format("%s¤Ï¹¶·â¤òµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4564 #else
4565                         msg_format("%^s ignores the attack.", m_name);
4566 #endif
4567
4568                 else if (percentage > 75)
4569 #ifdef JP
4570 msg_format("%s¤Ï¹¶·â¤Ë¸ª¤ò¤¹¤¯¤á¤¿¡£", m_name);
4571 #else
4572                         msg_format("%^s shrugs off the attack.", m_name);
4573 #endif
4574
4575                 else if (percentage > 50)
4576 #ifdef JP
4577 msg_format("%^s¤Ï¤¦¤á¤¤¤¿¡£", m_name);
4578 #else
4579                         msg_format("%^s groans.", m_name);
4580 #endif
4581
4582                 else if (percentage > 35)
4583 #ifdef JP
4584 msg_format("%s¤Ï¶ì¤·¤²¤Ë¤¦¤á¤¤¤¿¡£", m_name);
4585 #else
4586                         msg_format("%^s moans.", m_name);
4587 #endif
4588
4589                 else if (percentage > 20)
4590 #ifdef JP
4591 msg_format("%^s¤Ïí´í°¤·¤¿¡£", m_name);
4592 #else
4593                         msg_format("%^s hesitates.", m_name);
4594 #endif
4595
4596                 else if (percentage > 10)
4597 #ifdef JP
4598 msg_format("%^s¤Ï¤¦¤Ê¤Ã¤¿¡£", m_name);
4599 #else
4600                         msg_format("%^s grunts.", m_name);
4601 #endif
4602
4603                 else
4604 #ifdef JP
4605 msg_format("%^s¤Ï¤è¤í¤á¤¤¤¿¡£", m_name);
4606 #else
4607                         msg_format("%^s staggers.", m_name);
4608 #endif
4609
4610         }
4611
4612
4613         /* Ghosts */
4614         else if (strchr("G", r_ptr->d_char))
4615
4616         {
4617                 if (percentage > 95)
4618 #ifdef JP
4619 msg_format("%s¤Ï¹¶·â¤òµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4620 #else
4621                         msg_format("%^s ignores the attack.", m_name);
4622 #endif
4623
4624                 else if (percentage > 75)
4625 #ifdef JP
4626 msg_format("%s¤Ï¹¶·â¤Ë¸ª¤ò¤¹¤¯¤á¤¿¡£", m_name);
4627 #else
4628                         msg_format("%^s shrugs off the attack.", m_name);
4629 #endif
4630
4631                 else if (percentage > 50)
4632 #ifdef JP
4633 msg_format("%s¤Ï¤¦¤á¤¤¤¿¡£", m_name);
4634 #else
4635                         msg_format("%^s moans.", m_name);
4636 #endif
4637
4638                 else if (percentage > 35)
4639 #ifdef JP
4640 msg_format("%^s¤Ïµã¤¤ï¤á¤¤¤¿¡£", m_name);
4641 #else
4642                         msg_format("%^s wails.", m_name);
4643 #endif
4644
4645                 else if (percentage > 20)
4646 #ifdef JP
4647 msg_format("%^s¤ÏËÊ¤¨¤¿¡£", m_name);
4648 #else
4649                         msg_format("%^s howls.", m_name);
4650 #endif
4651
4652                 else if (percentage > 10)
4653 #ifdef JP
4654 msg_format("%s¤Ï¼å¡¹¤·¤¯¤¦¤á¤¤¤¿¡£", m_name);
4655 #else
4656                         msg_format("%^s moans softly.", m_name);
4657 #endif
4658
4659                 else
4660 #ifdef JP
4661 msg_format("%^s¤Ï¤«¤¹¤«¤Ë¤¦¤á¤¤¤¿¡£", m_name);
4662 #else
4663                         msg_format("%^s sighs.", m_name);
4664 #endif
4665
4666         }
4667
4668
4669         /* Dogs and Hounds */
4670         else if (strchr("CZ", r_ptr->d_char))
4671         {
4672 #ifdef JP
4673                 if (percentage > 95)
4674                         msg_format("%^s¤Ï¹¶·â¤Ë¸ª¤ò¤¹¤¯¤á¤¿¡£", m_name);
4675                 else if (percentage > 75)
4676                         msg_format("%^s¤ÏÄË¤ß¤Ç¤¦¤Ê¤Ã¤¿¡£", m_name);
4677                 else if (percentage > 50)
4678                         msg_format("%^s¤ÏÄË¤ß¤Ç¥¥ã¥ó¥¥ã¥óËÊ¤¨¤¿¡£", m_name);
4679                 else if (percentage > 35)
4680                         msg_format("%^s¤ÏÄË¤ß¤ÇÌÄ¤¤ï¤á¤¤¤¿¡£", m_name);
4681                 else if (percentage > 20)
4682                         msg_format("%^s¤Ï¶ìÄË¤Î¤¢¤Þ¤êÌÄ¤¤ï¤á¤¤¤¿¡£", m_name);
4683                 else if (percentage > 10)
4684                         msg_format("%^s¤Ï¶ìÄË¤Ç¤â¤À¤¨¶ì¤·¤ó¤À¡£", m_name);
4685                 else
4686                         msg_format("%^s¤Ï¼å¡¹¤·¤¯ËÊ¤¨¤¿¡£", m_name);
4687 #else
4688                 if (percentage > 95)
4689                         msg_format("%^s shrugs off the attack.", m_name);
4690                 else if (percentage > 75)
4691                         msg_format("%^s snarls with pain.", m_name);
4692                 else if (percentage > 50)
4693                         msg_format("%^s yelps in pain.", m_name);
4694                 else if (percentage > 35)
4695                         msg_format("%^s howls in pain.", m_name);
4696                 else if (percentage > 20)
4697                         msg_format("%^s howls in agony.", m_name);
4698                 else if (percentage > 10)
4699                         msg_format("%^s writhes in agony.", m_name);
4700                 else
4701                         msg_format("%^s yelps feebly.", m_name);
4702 #endif
4703
4704         }
4705
4706         /* One type of monsters (ignore,squeal,shriek) */
4707         else if (strchr("Xbilqrt", r_ptr->d_char))
4708         {
4709 #ifdef JP
4710                 if (percentage > 95)
4711                         msg_format("%^s¤Ï¹¶·â¤òµ¤¤Ë¤È¤á¤Æ¤¤¤Ê¤¤¡£", m_name);
4712                 else if (percentage > 75)
4713                         msg_format("%^s¤ÏÄË¤ß¤Ç¤¦¤Ê¤Ã¤¿¡£", m_name);
4714                 else if (percentage > 50)
4715                         msg_format("%^s¤ÏÄË¤ß¤Ç¶«¤ó¤À¡£", m_name);
4716                 else if (percentage > 35)
4717                         msg_format("%^s¤ÏÄË¤ß¤ÇÀä¶«¤·¤¿¡£", m_name);
4718                 else if (percentage > 20)
4719                         msg_format("%^s¤Ï¶ìÄË¤Î¤¢¤Þ¤êÀä¶«¤·¤¿¡£", m_name);
4720                 else if (percentage > 10)
4721                         msg_format("%^s¤Ï¶ìÄË¤Ç¤â¤À¤¨¶ì¤·¤ó¤À¡£", m_name);
4722                 else
4723                         msg_format("%^s¤Ï¼å¡¹¤·¤¯¶«¤ó¤À¡£", m_name);
4724 #else
4725                 if (percentage > 95)
4726                         msg_format("%^s ignores the attack.", m_name);
4727                 else if (percentage > 75)
4728                         msg_format("%^s grunts with pain.", m_name);
4729                 else if (percentage > 50)
4730                         msg_format("%^s squeals in pain.", m_name);
4731                 else if (percentage > 35)
4732                         msg_format("%^s shrieks in pain.", m_name);
4733                 else if (percentage > 20)
4734                         msg_format("%^s shrieks in agony.", m_name);
4735                 else if (percentage > 10)
4736                         msg_format("%^s writhes in agony.", m_name);
4737                 else
4738                         msg_format("%^s cries out feebly.", m_name);
4739 #endif
4740
4741         }
4742
4743         /* Another type of monsters (shrug,cry,scream) */
4744         else
4745         {
4746 #ifdef JP
4747                 if (percentage > 95)
4748                         msg_format("%^s¤Ï¹¶·â¤Ë¸ª¤ò¤¹¤¯¤á¤¿¡£", m_name);
4749                 else if (percentage > 75)
4750                         msg_format("%^s¤ÏÄË¤ß¤Ç¤¦¤Ê¤Ã¤¿¡£", m_name);
4751                 else if (percentage > 50)
4752                         msg_format("%^s¤ÏÄË¤ß¤Ç¶«¤ó¤À¡£", m_name);
4753                 else if (percentage > 35)
4754                         msg_format("%^s¤ÏÄË¤ß¤ÇÀä¶«¤·¤¿¡£", m_name);
4755                 else if (percentage > 20)
4756                         msg_format("%^s¤Ï¶ìÄË¤Î¤¢¤Þ¤êÀä¶«¤·¤¿¡£", m_name);
4757                 else if (percentage > 10)
4758                         msg_format("%^s¤Ï¶ìÄË¤Ç¤â¤À¤¨¶ì¤·¤ó¤À¡£", m_name);
4759                 else
4760                         msg_format("%^s¤Ï¼å¡¹¤·¤¯¶«¤ó¤À¡£", m_name);
4761 #else
4762                 if (percentage > 95)
4763                         msg_format("%^s shrugs off the attack.", m_name);
4764                 else if (percentage > 75)
4765                         msg_format("%^s grunts with pain.", m_name);
4766                 else if (percentage > 50)
4767                         msg_format("%^s cries out in pain.", m_name);
4768                 else if (percentage > 35)
4769                         msg_format("%^s screams in pain.", m_name);
4770                 else if (percentage > 20)
4771                         msg_format("%^s screams in agony.", m_name);
4772                 else if (percentage > 10)
4773                         msg_format("%^s writhes in agony.", m_name);
4774                 else
4775                         msg_format("%^s cries out feebly.", m_name);
4776 #endif
4777
4778         }
4779 }
4780
4781
4782 /*
4783  * Learn about an "observed" resistance.
4784  */
4785 void update_smart_learn(int m_idx, int what)
4786 {
4787         monster_type *m_ptr = &m_list[m_idx];
4788
4789         monster_race *r_ptr = &r_info[m_ptr->r_idx];
4790
4791
4792         /* Not allowed to learn */
4793         if (!smart_learn) return;
4794
4795         /* Too stupid to learn anything */
4796         if (r_ptr->flags2 & (RF2_STUPID)) return;
4797
4798         /* Not intelligent, only learn sometimes */
4799         if (!(r_ptr->flags2 & (RF2_SMART)) && (randint0(100) < 50)) return;
4800
4801
4802         /* XXX XXX XXX */
4803
4804         /* Analyze the knowledge */
4805         switch (what)
4806         {
4807         case DRS_ACID:
4808                 if (p_ptr->resist_acid) m_ptr->smart |= (SM_RES_ACID);
4809                 if (IS_OPPOSE_ACID()) m_ptr->smart |= (SM_OPP_ACID);
4810                 if (p_ptr->immune_acid) m_ptr->smart |= (SM_IMM_ACID);
4811                 break;
4812
4813         case DRS_ELEC:
4814                 if (p_ptr->resist_elec) m_ptr->smart |= (SM_RES_ELEC);
4815                 if (IS_OPPOSE_ELEC()) m_ptr->smart |= (SM_OPP_ELEC);
4816                 if (p_ptr->immune_elec) m_ptr->smart |= (SM_IMM_ELEC);
4817                 break;
4818
4819         case DRS_FIRE:
4820                 if (p_ptr->resist_fire) m_ptr->smart |= (SM_RES_FIRE);
4821                 if (IS_OPPOSE_FIRE()) m_ptr->smart |= (SM_OPP_FIRE);
4822                 if (p_ptr->immune_fire) m_ptr->smart |= (SM_IMM_FIRE);
4823                 break;
4824
4825         case DRS_COLD:
4826                 if (p_ptr->resist_cold) m_ptr->smart |= (SM_RES_COLD);
4827                 if (IS_OPPOSE_COLD()) m_ptr->smart |= (SM_OPP_COLD);
4828                 if (p_ptr->immune_cold) m_ptr->smart |= (SM_IMM_COLD);
4829                 break;
4830
4831         case DRS_POIS:
4832                 if (p_ptr->resist_pois) m_ptr->smart |= (SM_RES_POIS);
4833                 if (IS_OPPOSE_POIS()) m_ptr->smart |= (SM_OPP_POIS);
4834                 break;
4835
4836
4837         case DRS_NETH:
4838                 if (p_ptr->resist_neth) m_ptr->smart |= (SM_RES_NETH);
4839                 break;
4840
4841         case DRS_LITE:
4842                 if (p_ptr->resist_lite) m_ptr->smart |= (SM_RES_LITE);
4843                 break;
4844
4845         case DRS_DARK:
4846                 if (p_ptr->resist_dark) m_ptr->smart |= (SM_RES_DARK);
4847                 break;
4848
4849         case DRS_FEAR:
4850                 if (p_ptr->resist_fear) m_ptr->smart |= (SM_RES_FEAR);
4851                 break;
4852
4853         case DRS_CONF:
4854                 if (p_ptr->resist_conf) m_ptr->smart |= (SM_RES_CONF);
4855                 break;
4856
4857         case DRS_CHAOS:
4858                 if (p_ptr->resist_chaos) m_ptr->smart |= (SM_RES_CHAOS);
4859                 break;
4860
4861         case DRS_DISEN:
4862                 if (p_ptr->resist_disen) m_ptr->smart |= (SM_RES_DISEN);
4863                 break;
4864
4865         case DRS_BLIND:
4866                 if (p_ptr->resist_blind) m_ptr->smart |= (SM_RES_BLIND);
4867                 break;
4868
4869         case DRS_NEXUS:
4870                 if (p_ptr->resist_nexus) m_ptr->smart |= (SM_RES_NEXUS);
4871                 break;
4872
4873         case DRS_SOUND:
4874                 if (p_ptr->resist_sound) m_ptr->smart |= (SM_RES_SOUND);
4875                 break;
4876
4877         case DRS_SHARD:
4878                 if (p_ptr->resist_shard) m_ptr->smart |= (SM_RES_SHARD);
4879                 break;
4880
4881         case DRS_FREE:
4882                 if (p_ptr->free_act) m_ptr->smart |= (SM_IMM_FREE);
4883                 break;
4884
4885         case DRS_MANA:
4886                 if (!p_ptr->msp) m_ptr->smart |= (SM_IMM_MANA);
4887                 break;
4888
4889         case DRS_REFLECT:
4890                 if (p_ptr->reflect) m_ptr-> smart |= (SM_IMM_REFLECT);
4891                 break;
4892         }
4893 }
4894
4895
4896 /*
4897  * Place the player in the dungeon XXX XXX
4898  */
4899 bool player_place(int y, int x)
4900 {
4901         /* Paranoia XXX XXX */
4902         if (cave[y][x].m_idx != 0) return FALSE;
4903
4904         /* Save player location */
4905         py = y;
4906         px = x;
4907
4908         /* Success */
4909         return TRUE;
4910 }
4911
4912
4913 /*
4914  * Drop all items carried by a monster
4915  */
4916 void monster_drop_carried_objects(monster_type *m_ptr)
4917 {
4918         s16b this_o_idx, next_o_idx = 0;
4919         object_type forge;
4920         object_type *o_ptr;
4921         object_type *q_ptr;
4922
4923
4924         /* Drop objects being carried */
4925         for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
4926         {
4927                 /* Acquire object */
4928                 o_ptr = &o_list[this_o_idx];
4929
4930                 /* Acquire next object */
4931                 next_o_idx = o_ptr->next_o_idx;
4932
4933                 /* Get local object */
4934                 q_ptr = &forge;
4935
4936                 /* Copy the object */
4937                 object_copy(q_ptr, o_ptr);
4938
4939                 /* Forget monster */
4940                 q_ptr->held_m_idx = 0;
4941
4942                 /* Delete the object */
4943                 delete_object_idx(this_o_idx);
4944
4945                 /* Drop it */
4946                 (void)drop_near(q_ptr, -1, m_ptr->fy, m_ptr->fx);
4947         }
4948
4949         /* Forget objects */
4950         m_ptr->hold_o_idx = 0;
4951 }