src/monster2.c

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