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