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