src/monster2.c

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