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