src/monster2.c

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