src/mspells4.c

   1 /*!
   2  * @file mspells4.c
   3  * @brief スペル実行処理 / Spell launch
   4  * @date 2014/07/14
   5  * @author Habu
   6  */
   7
   8
   9 #include "angband.h"
  10
  11 /*!
  12 * @brief モンスターIDを取り、モンスター名をm_nameに代入する /
  13 * @param m_idx モンスターID
  14 * @param m_name モンスター名を入力する配列
  15 */
  16 void monster_name(int m_idx, char* m_name)
  17 {
  18     monster_type    *m_ptr = &m_list[m_idx];
  19     monster_desc(m_name, m_ptr, 0x00);
  20 }
  21
  22 /*!
  23 * @brief モンスター2体がプレイヤーの近くに居るかの判定 /
  24 * @param m_idx モンスターID一体目
  25 * @param t_idx モンスターID二体目
  26 * @return モンスター2体のどちらかがプレイヤーの近くに居ればTRUE、どちらも遠ければFALSEを返す。
  27 */
  28 bool monster_near_player(int m_idx, int t_idx)
  29 {
  30     monster_type    *m_ptr = &m_list[m_idx];
  31     monster_type    *t_ptr = &m_list[t_idx];
  32     return (m_ptr->cdis <= MAX_SIGHT) || (t_ptr->cdis <= MAX_SIGHT);
  33 }
  34
  35 /*!
  36 * @brief プレイヤーがモンスターを見ることができるかの判定 /
  37 * @param m_idx モンスターID
  38 * @return プレイヤーがモンスターを見ることができるならTRUE、そうでなければFALSEを返す。
  39 */
  40 bool see_monster(int m_idx)
  41 {
  42     monster_type    *m_ptr = &m_list[m_idx];
  43     return is_seen(m_ptr);
  44 }
  45
  46 /*!
  47 * @brief モンスターの唱えた呪文を青魔法で学習できるか判定する /
  48 * @param m_idx モンスターID
  49 * @return プレイヤーが青魔法で学習できるならTRUE、そうでなければFALSEを返す。
  50 */
  51 bool spell_learnable(int m_idx)
  52 {
  53     monster_type    *m_ptr = &m_list[m_idx];
  54     /* Extract the "see-able-ness" */
  55     bool seen = (!p_ptr->blind && m_ptr->ml);
  56
  57     bool maneable = player_has_los_bold(m_ptr->fy, m_ptr->fx);
  58     return (seen && maneable && !world_monster);
  59 }
  60
  61 /*!
  62 * @brief モンスターIDからモンスターのレベルを取得する /
  63 * @param m_idx モンスターID
  64 * @return モンスターのレベル
  65 */
  66 int monster_level_idx(int m_idx)
  67 {
  68     monster_type    *m_ptr = &m_list[m_idx];
  69     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
  70     int rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
  71     return rlev;
  72 }
  73
  74 /*!
  75 * @brief モンスターIDからPOWERFULフラグの有無を取得する /
  76 * @param m_idx モンスターID
  77 * @return POWERFULフラグがあればTRUE、なければFALSEを返す。
  78 */
  79 bool monster_is_powerful(int m_idx)
  80 {
  81     monster_type    *m_ptr = &m_list[m_idx];
  82     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
  83     bool powerful = r_ptr->flags2 & RF2_POWERFUL ? TRUE : FALSE;
  84     return powerful;
  85 }
  86
  87 /*!
  88 * @brief モンスターがユニーク召喚可能であるかを判定する /
  89 * @param m_idx モンスターID
  90 * @return 召喚可能であればPM_ALLOW_UNIQUEを返す。
  91 */
  92 u32b monster_u_mode(int m_idx)
  93 {
  94         u32b u_mode = 0L;
  95     monster_type    *m_ptr = &m_list[m_idx];
  96         bool pet = is_pet(m_ptr);
  97         if (!pet) u_mode |= PM_ALLOW_UNIQUE;
  98         return u_mode;
  99 }
 100
 101 /*!
 102 * @brief モンスターを起こす /
 103 * @param t_idx モンスターID
 104 */
 105 void monster_wakeup(int t_idx)
 106 {
 107     (void)set_monster_csleep(t_idx, 0);
 108 }
 109
 110 /*!
 111  * @brief モンスターが呪文行使する際のメッセージを処理する汎用関数 /
 112  * @param m_idx 呪文を唱えるモンスターID
 113  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 114  * @param msg1 msg_flagがTRUEで、プレイヤーを対象とする場合のメッセージ
 115  * @param msg2 msg_flagがTRUEで、モンスターを対象とする場合のメッセージ
 116  * @param msg3 msg_flagがFALSEで、プレイヤーを対象とする場合のメッセージ
 117  * @param msg4 msg_flagがFALSEで、モンスターを対象とする場合のメッセージ
 118  * @param msg_flag メッセージを分岐するためのフラグ
 119  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 120  */
 121 void monspell_message_base(int m_idx, int t_idx, cptr msg1, cptr msg2, cptr msg3, cptr msg4, bool msg_flag, int TARGET_TYPE)
 122 {
 123     bool known = monster_near_player(m_idx, t_idx);
 124     bool see_either = see_monster(m_idx) || see_monster(t_idx);
 125     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
 126     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
 127         char m_name[80], t_name[80];
 128     monster_name(m_idx, m_name);
 129         monster_name(t_idx, t_name);
 130
 131     if (mon_to_player || (mon_to_mon && known && see_either))
 132         disturb(1, 1);
 133
 134     if (msg_flag)
 135     {
 136         if (mon_to_player)
 137             msg_format(msg1, m_name);
 138         else if (mon_to_mon && known && see_either)
 139             msg_format(msg2, m_name);
 140     }
 141     else
 142     {
 143         if (mon_to_player)
 144         {
 145             msg_format(msg3, m_name);
 146         }
 147         else if (mon_to_mon && known && see_either)
 148         {
 149             msg_format(msg4, m_name, t_name);
 150         }
 151     }
 152
 153     if (mon_to_mon && known && !see_either)
 154         mon_fight = TRUE;
 155 }
 156
 157 /*!
 158 * @brief モンスターが呪文行使する際のメッセージを処理する汎用関数。盲目時と通常時のメッセージを切り替える。 /
 159 * @param m_idx 呪文を唱えるモンスターID
 160 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 161 * @param msg1 プレイヤーが盲目状態のメッセージ
 162 * @param msg2 プレイヤーが盲目でなく、プレイヤーを対象とする場合のメッセージ
 163 * @param msg3 プレイヤーが盲目でなく、モンスター対象とする場合のメッセージ
 164 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 165 */
 166 void monspell_message(int m_idx, int t_idx, cptr msg1, cptr msg2, cptr msg3, int TARGET_TYPE)
 167 {
 168     monspell_message_base(m_idx, t_idx, msg1, msg1, msg2, msg3, p_ptr->blind, TARGET_TYPE);
 169 }
 170
 171 /*!
 172 * @brief モンスターが呪文行使する際のメッセージを処理する汎用関数。対モンスターと対プレイヤーのメッセージを切り替える。 /
 173 * @param m_idx 呪文を唱えるモンスターID
 174 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 175 * @param msg1 プレイヤーを対象とする場合のメッセージ
 176 * @param msg2 モンスター対象とする場合のメッセージ
 177 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 178 */
 179 void simple_monspell_message(int m_idx, int t_idx, cptr msg1, cptr msg2, int TARGET_TYPE)
 180 {
 181     monspell_message_base(m_idx, t_idx, msg1, msg2, msg1, msg2, p_ptr->blind, TARGET_TYPE);
 182 }
 183
 184 /*!
 185  * @brief RF4_SHRIEKの処理。叫び。 /
 186  * @param m_idx 呪文を唱えるモンスターID
 187  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 188  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 189  */
 190 void spell_RF4_SHRIEK(int m_idx, int t_idx, int TARGET_TYPE)
 191 {
 192     simple_monspell_message(m_idx, t_idx,
 193         _("%^sがかん高い金切り声をあげた。", "%^s makes a high pitched shriek."),
 194         _("%^sが%sに向かって叫んだ。", "%^s shrieks at %s."),
 195         TARGET_TYPE);
 196
 197     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 198     {
 199         aggravate_monsters(m_idx);
 200     }
 201     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
 202     {
 203         monster_wakeup(t_idx);
 204     }
 205 }
 206
 207 /*!
 208  * @brief RF4_DISPELの処理。魔力消去。 /
 209  * @param m_idx 呪文を唱えるモンスターID
 210  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 211  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 212  */
 213 void spell_RF4_DISPEL(int m_idx, int t_idx, int TARGET_TYPE)
 214 {
 215         char m_name[80], t_name[80];
 216     monster_name(m_idx, m_name);
 217         monster_name(t_idx, t_name);
 218
 219     monspell_message(m_idx, t_idx,
 220         _("%^sが何かを力強くつぶやいた。", "%^s mumbles powerfully."),
 221         _("%^sが魔力消去の呪文を念じた。", "%^s invokes a dispel magic."),
 222         _("%^sが%sに対して魔力消去の呪文を念じた。", "%^s invokes a dispel magic at %s."),
 223         TARGET_TYPE);
 224
 225     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 226     {
 227         dispel_player();
 228         if (p_ptr->riding) dispel_monster_status(p_ptr->riding);
 229
 230         if ((p_ptr->pseikaku == SEIKAKU_COMBAT) || (inventory[INVEN_BOW].name1 == ART_CRIMSON))
 231             msg_print(_("やりやがったな！", ""));
 232
 233         learn_spell(MS_DISPEL);
 234     }
 235     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
 236     {
 237         if (t_idx == p_ptr->riding) dispel_player();
 238         dispel_monster_status(t_idx);
 239     }
 240 }
 241
 242 /*!
 243 * @brief RF4_ROCKETの処理。ロケット。 /
 244 * @param y 対象の地点のy座標
 245 * @param x 対象の地点のx座標
 246 * @param m_idx 呪文を唱えるモンスターID
 247 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 248 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 249 * @return ダメージ量を返す。
 250 */
 251 int spell_RF4_ROCKET(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 252 {
 253     int dam;
 254
 255     monspell_message(m_idx, t_idx,
 256         _("%^sが何かを射った。", "%^s shoots something."),
 257         _("%^sがロケットを発射した。", "%^s fires a rocket."),
 258         _("%^sが%sにロケットを発射した。", "%^s fires a rocket at %s."),
 259         TARGET_TYPE);
 260
 261     dam = monspell_damage((MS_ROCKET), m_idx, DAM_ROLL);
 262     breath(y, x, m_idx, GF_ROCKET, dam, 2, FALSE, MS_ROCKET, TARGET_TYPE);
 263     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 264         update_smart_learn(m_idx, DRS_SHARD);
 265     return dam;
 266 }
 267
 268 /*!
 269 * @brief RF4_SHOOTの処理。射撃。 /
 270 * @param y 対象の地点のy座標
 271 * @param x 対象の地点のx座標
 272 * @param m_idx 呪文を唱えるモンスターID
 273 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 274 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 275 * @return ダメージ量を返す。
 276 */
 277 int spell_RF4_SHOOT(int y, int x, int m_idx, int t_idx,int TARGET_TYPE)
 278 {
 279     int dam;
 280
 281     monspell_message(m_idx, t_idx,
 282         _("%^sが奇妙な音を発した。", "%^s makes a strange noise."),
 283         _("%^sが矢を放った。", "%^s fires an arrow."),
 284         _("%^sが%sに矢を放った。", "%^s fires an arrow at %s."),
 285         TARGET_TYPE);
 286
 287     dam = monspell_damage((MS_SHOOT), m_idx, DAM_ROLL);
 288     bolt(m_idx, y, x, GF_ARROW, dam, MS_SHOOT, TARGET_TYPE);
 289     sound(SOUND_SHOOT);
 290
 291     return dam;
 292 }
 293
 294 /*!
 295 * @brief RF4_BR_*の処理。各種ブレス。 /
 296 * @param GF_TYPE ブレスの属性
 297 * @param y 対象の地点のy座標
 298 * @param x 対象の地点のx座標
 299 * @param m_idx 呪文を唱えるモンスターID
 300 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 301 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 302 * @return ダメージ量を返す。
 303 */
 304 int spell_RF4_BREATH(int GF_TYPE, int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 305 {
 306     int dam, ms_type, drs_type;
 307     cptr type_s;
 308     bool smart_learn = TRUE;
 309     monster_type    *m_ptr = &m_list[m_idx];
 310     bool known = monster_near_player(m_idx, t_idx);
 311     bool see_either = see_monster(m_idx) || see_monster(t_idx);
 312     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
 313     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
 314         char m_name[80], t_name[80];
 315     monster_name(m_idx, m_name);
 316         monster_name(t_idx, t_name);
 317
 318     switch (GF_TYPE)
 319     {
 320     case GF_ACID:
 321         dam = monspell_damage((MS_BR_ACID), m_idx, DAM_ROLL);
 322         type_s = _("酸", "acid");
 323         ms_type = MS_BR_ACID;
 324         drs_type = DRS_ACID;
 325         break;
 326     case GF_ELEC:
 327         dam = monspell_damage((MS_BR_ELEC), m_idx, DAM_ROLL);
 328         type_s = _("稲妻", "lightning");
 329         ms_type = MS_BR_ELEC;
 330         drs_type = DRS_ELEC;
 331         break;
 332     case GF_FIRE:
 333         dam = monspell_damage((MS_BR_FIRE), m_idx, DAM_ROLL);
 334         type_s = _("火炎", "fire");
 335         ms_type = MS_BR_FIRE;
 336         drs_type = DRS_FIRE;
 337         break;
 338     case GF_COLD:
 339         dam = monspell_damage((MS_BR_COLD), m_idx, DAM_ROLL);
 340         type_s = _("冷気", "frost");
 341         ms_type = MS_BR_COLD;
 342         drs_type = DRS_COLD;
 343         break;
 344     case GF_POIS:
 345         dam = monspell_damage((MS_BR_POIS), m_idx, DAM_ROLL);
 346         type_s = _("ガス", "gas");
 347         ms_type = MS_BR_POIS;
 348         drs_type = DRS_POIS;
 349         break;
 350     case GF_NETHER:
 351         dam = monspell_damage((MS_BR_NETHER), m_idx, DAM_ROLL);
 352         type_s = _("地獄", "nether");
 353         ms_type = MS_BR_NETHER;
 354         drs_type = DRS_NETH;
 355         break;
 356     case GF_LITE:
 357         dam = monspell_damage((MS_BR_LITE), m_idx, DAM_ROLL);
 358         type_s = _("閃光", "light");
 359         ms_type = MS_BR_LITE;
 360         drs_type = DRS_LITE;
 361         break;
 362     case GF_DARK:
 363         dam = monspell_damage((MS_BR_DARK), m_idx, DAM_ROLL);
 364         type_s = _("暗黒", "darkness");
 365         ms_type = MS_BR_DARK;
 366         drs_type = DRS_DARK;
 367         break;
 368     case GF_CONFUSION:
 369         dam = monspell_damage((MS_BR_CONF), m_idx, DAM_ROLL);
 370         type_s = _("混乱", "confusion");
 371         ms_type = MS_BR_CONF;
 372         drs_type = DRS_CONF;
 373         break;
 374     case GF_SOUND:
 375         dam = monspell_damage((MS_BR_SOUND), m_idx, DAM_ROLL);
 376         type_s = _("轟音", "sound");
 377         ms_type = MS_BR_SOUND;
 378         drs_type = DRS_SOUND;
 379         break;
 380     case GF_CHAOS:
 381         dam = monspell_damage((MS_BR_CHAOS), m_idx, DAM_ROLL);
 382         type_s = _("カオス", "chaos");
 383         ms_type = MS_BR_CHAOS;
 384         drs_type = DRS_CHAOS;
 385         break;
 386     case GF_DISENCHANT:
 387         dam = monspell_damage((MS_BR_DISEN), m_idx, DAM_ROLL);
 388         type_s = _("劣化", "disenchantment");
 389         ms_type = MS_BR_DISEN;
 390         drs_type = DRS_DISEN;
 391         break;
 392     case GF_NEXUS:
 393         dam = monspell_damage((MS_BR_NEXUS), m_idx, DAM_ROLL);
 394         type_s = _("因果混乱", "nexus");
 395         ms_type = MS_BR_NEXUS;
 396         drs_type = DRS_NEXUS;
 397         break;
 398     case GF_TIME:
 399         dam = monspell_damage((MS_BR_TIME), m_idx, DAM_ROLL);
 400         type_s = _("時間逆転", "time");
 401         ms_type = MS_BR_TIME;
 402         smart_learn = FALSE;
 403         break;
 404     case GF_INERTIA:
 405         dam = monspell_damage((MS_BR_INERTIA), m_idx, DAM_ROLL);
 406         type_s = _("遅鈍", "inertia");
 407         ms_type = MS_BR_INERTIA;
 408         smart_learn = FALSE;
 409         break;
 410     case GF_GRAVITY:
 411         dam = monspell_damage((MS_BR_GRAVITY), m_idx, DAM_ROLL);
 412         type_s = _("重力", "gravity");
 413         ms_type = MS_BR_GRAVITY;
 414         smart_learn = FALSE;
 415         break;
 416     case GF_SHARDS:
 417         dam = monspell_damage((MS_BR_SHARDS), m_idx, DAM_ROLL);
 418         type_s = _("破片", "shards");
 419         ms_type = MS_BR_SHARDS;
 420         drs_type = DRS_SHARD;
 421         break;
 422     case GF_PLASMA:
 423         dam = monspell_damage((MS_BR_PLASMA), m_idx, DAM_ROLL);
 424         type_s = _("プラズマ", "plasma");
 425         ms_type = MS_BR_PLASMA;
 426         smart_learn = FALSE;
 427         break;
 428     case GF_FORCE:
 429         dam = monspell_damage((MS_BR_FORCE), m_idx, DAM_ROLL);
 430         type_s = _("フォース", "force");
 431         ms_type = MS_BR_FORCE;
 432         smart_learn = FALSE;
 433         break;
 434     case GF_MANA:
 435         dam = monspell_damage((MS_BR_MANA), m_idx, DAM_ROLL);
 436         type_s = _("魔力", "mana");
 437         ms_type = MS_BR_MANA;
 438         smart_learn = FALSE;
 439         break;
 440     case GF_NUKE:
 441         dam = monspell_damage((MS_BR_NUKE), m_idx, DAM_ROLL);
 442         type_s = _("放射性廃棄物", "toxic waste");
 443         ms_type = MS_BR_NUKE;
 444         drs_type = DRS_POIS;
 445         break;
 446     case GF_DISINTEGRATE:
 447         dam = monspell_damage((MS_BR_DISI), m_idx, DAM_ROLL);
 448         type_s = _("分解", "disintegration");
 449         ms_type = MS_BR_DISI;
 450         smart_learn = FALSE;
 451         break;
 452     default:
 453         break;
 454     }
 455
 456     if (mon_to_player || (mon_to_mon && known && see_either))
 457         disturb(1, 1);
 458
 459     if (m_ptr->r_idx == MON_JAIAN && GF_TYPE == GF_SOUND)
 460     {
 461         msg_format(_("「ボォエ～～～～～～」", "'Booooeeeeee'"));
 462     }
 463     else if (m_ptr->r_idx == MON_BOTEI && GF_TYPE == GF_SHARDS)
 464     {
 465         msg_format(_("「ボ帝ビルカッター！！！」", "'Boty-Build cutter!!!'"));
 466     }
 467     else if (p_ptr->blind)
 468     {
 469         if (mon_to_player || (mon_to_mon && known && see_either))
 470             msg_format(_("%^sが何かのブレスを吐いた。", "%^s breathes."), m_name);
 471     }
 472     else
 473     {
 474         if (mon_to_player)
 475         {
 476             msg_format(_("%^sが%^sのブレスを吐いた。", "%^s breathes %^s."), m_name, type_s);
 477         }
 478         else if (mon_to_mon && known && see_either)
 479         {
 480             _(msg_format("%^sが%^sに%^sのブレスを吐いた。", m_name, t_name, type_s),
 481               msg_format("%^s breathes %^s at %^s.", m_name, type_s, t_name));
 482         }
 483     }
 484
 485     if (mon_to_mon && known && !see_either)
 486         mon_fight = TRUE;
 487
 488     sound(SOUND_BREATH);
 489     breath(y, x, m_idx, GF_TYPE, dam, 0, TRUE, ms_type, TARGET_TYPE);
 490     if (smart_learn && mon_to_player)
 491         update_smart_learn(m_idx, drs_type);
 492
 493     return dam;
 494 }
 495
 496 /*!
 497 * @brief RF4_BA_NUKEの処理。放射能球。 /
 498 * @param y 対象の地点のy座標
 499 * @param x 対象の地点のx座標
 500 * @param m_idx 呪文を唱えるモンスターID
 501 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 502 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 503 * @return ダメージ量を返す。
 504 */
 505 int spell_RF4_BA_NUKE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 506 {
 507     int dam;
 508
 509     monspell_message(m_idx, t_idx,
 510         _("%^sが何かをつぶやいた。", "%^s mumbles."),
 511         _("%^sが放射能球を放った。", "%^s casts a ball of radiation."),
 512         _("%^sが%sに放射能球を放った。", "%^s casts a ball of radiation at %s."),
 513         TARGET_TYPE);
 514
 515     dam = monspell_damage((MS_BALL_NUKE), m_idx, DAM_ROLL);
 516     breath(y, x, m_idx, GF_NUKE, dam, 2, FALSE, MS_BALL_NUKE, TARGET_TYPE);
 517     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 518         update_smart_learn(m_idx, DRS_POIS);
 519
 520     return dam;
 521 }
 522
 523 /*!
 524 * @brief RF4_BA_CHAOの処理。純ログルス。 /
 525 * @param y 対象の地点のy座標
 526 * @param x 対象の地点のx座標
 527 * @param m_idx 呪文を唱えるモンスターID
 528 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 529 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 530 * @return ダメージ量を返す。
 531 */
 532 int spell_RF4_BA_CHAO(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 533 {
 534     int dam;
 535
 536     monspell_message(m_idx, t_idx,
 537         _("%^sが恐ろしげにつぶやいた。", "%^s mumbles frighteningly."),
 538         _("%^sが純ログルスを放った。", "%^s invokes a raw Logrus."),
 539         _("%^sが%sに純ログルスを放った。", "%^s invokes raw Logrus upon %s."),
 540         TARGET_TYPE);
 541
 542     dam = monspell_damage((MS_BALL_CHAOS), m_idx, DAM_ROLL);
 543     breath(y, x, m_idx, GF_CHAOS, dam, 4, FALSE, MS_BALL_CHAOS, TARGET_TYPE);
 544     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 545         update_smart_learn(m_idx, DRS_CHAOS);
 546
 547     return dam;
 548 }
 549
 550 /*!
 551 * @brief RF5_BA_ACIDの処理。アシッド・ボール。 /
 552 * @param y 対象の地点のy座標
 553 * @param x 対象の地点のx座標
 554 * @param m_idx 呪文を唱えるモンスターID
 555 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 556 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 557 * @return ダメージ量を返す。
 558 */
 559 int spell_RF5_BA_ACID(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 560 {
 561     int dam, rad;
 562
 563     monspell_message(m_idx, t_idx,
 564         _("%^sが何かをつぶやいた。", "%^s mumbles."),
 565         _("%^sがアシッド・ボールの呪文を唱えた。", "%^s casts an acid ball."),
 566         _("%^sが%sに向かってアシッド・ボールの呪文を唱えた。",
 567           "%^s casts an acid ball at %s."),
 568         TARGET_TYPE);
 569
 570     rad = monster_is_powerful(m_idx) ? 4 : 2;
 571     dam = monspell_damage((MS_BALL_ACID), m_idx, DAM_ROLL);
 572     breath(y, x, m_idx, GF_ACID, dam, rad, FALSE, MS_BALL_ACID, TARGET_TYPE);
 573     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 574         update_smart_learn(m_idx, DRS_ACID);
 575
 576     return dam;
 577 }
 578
 579 /*!
 580 * @brief RF5_BA_ELECの処理。サンダー・ボール。 /
 581 * @param y 対象の地点のy座標
 582 * @param x 対象の地点のx座標
 583 * @param m_idx 呪文を唱えるモンスターID
 584 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 585 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 586 * @return ダメージ量を返す。
 587 */
 588 int spell_RF5_BA_ELEC(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 589 {
 590     int dam, rad;
 591
 592     monspell_message(m_idx, t_idx,
 593         _("%^sが何かをつぶやいた。", "%^s mumbles."),
 594         _("%^sがサンダー・・ボールの呪文を唱えた。", "%^s casts a lightning ball."),
 595         _("%^sが%sに向かってサンダー・ボールの呪文を唱えた。",
 596           "%^s casts a lightning ball at %s."),
 597         TARGET_TYPE);
 598
 599     rad = monster_is_powerful(m_idx) ? 4 : 2;
 600     dam = monspell_damage((MS_BALL_ELEC), m_idx, DAM_ROLL);
 601     breath(y, x, m_idx, GF_ELEC, dam, rad, FALSE, MS_BALL_ELEC, TARGET_TYPE);
 602     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 603         update_smart_learn(m_idx, DRS_ELEC);
 604
 605     return dam;
 606 }
 607
 608 /*!
 609 * @brief RF5_BA_FIREの処理。ファイア・ボール。 /
 610 * @param y 対象の地点のy座標
 611 * @param x 対象の地点のx座標
 612 * @param m_idx 呪文を唱えるモンスターID
 613 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 614 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 615 * @return ダメージ量を返す。
 616 */
 617 int spell_RF5_BA_FIRE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 618 {
 619     int dam, rad;
 620     monster_type    *m_ptr = &m_list[m_idx];
 621
 622     if (m_ptr->r_idx == MON_ROLENTO)
 623     {
 624         monspell_message(m_idx, t_idx,
 625             _("%sが何かを投げた。", "%^s throws something."),
 626             _("%sは手榴弾を投げた。", "%^s throws a hand grenade."),
 627             _("%^sが%^sに向かって手榴弾を投げた。", "%^s throws a hand grenade."),
 628             TARGET_TYPE);
 629     }
 630     else
 631     {
 632         monspell_message(m_idx, t_idx,
 633             _("%^sが何かをつぶやいた。", "%^s mumbles."),
 634             _("%^sがファイア・ボールの呪文を唱えた。", "%^s casts a fire ball."),
 635             _("%^sが%sに向かってファイア・ボールの呪文を唱えた。",
 636             "%^s casts a fire ball at %s."),
 637             TARGET_TYPE);
 638     }
 639     rad = monster_is_powerful(m_idx) ? 4 : 2;
 640     dam = monspell_damage((MS_BALL_FIRE), m_idx, DAM_ROLL);
 641     breath(y, x, m_idx, GF_FIRE, dam, rad, FALSE, MS_BALL_FIRE, TARGET_TYPE);
 642     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 643         update_smart_learn(m_idx, DRS_FIRE);
 644
 645     return dam;
 646 }
 647
 648 /*!
 649 * @brief RF5_BA_COLDの処理。アイス・ボール。 /
 650 * @param y 対象の地点のy座標
 651 * @param x 対象の地点のx座標
 652 * @param m_idx 呪文を唱えるモンスターID
 653 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 654 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 655 * @return ダメージ量を返す。
 656 */
 657 int spell_RF5_BA_COLD(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 658 {
 659     int dam, rad;
 660
 661     monspell_message(m_idx, t_idx,
 662         _("%^sが何かをつぶやいた。", "%^s mumbles."),
 663         _("%^sがアイス・ボールの呪文を唱えた。", "%^s casts a frost ball."),
 664         _("%^sが%sに向かってアイス・ボールの呪文を唱えた。",
 665         "%^s casts a frost ball at %s."),
 666         TARGET_TYPE);
 667
 668     rad = monster_is_powerful(m_idx) ? 4 : 2;
 669     dam = monspell_damage((MS_BALL_COLD), m_idx, DAM_ROLL);
 670     breath(y, x, m_idx, GF_COLD, dam, rad, FALSE, MS_BALL_COLD, TARGET_TYPE);
 671     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 672         update_smart_learn(m_idx, DRS_COLD);
 673
 674     return dam;
 675 }
 676
 677 /*!
 678 * @brief RF5_BA_POISの処理。悪臭雲。 /
 679 * @param y 対象の地点のy座標
 680 * @param x 対象の地点のx座標
 681 * @param m_idx 呪文を唱えるモンスターID
 682 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 683 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 684 * @return ダメージ量を返す。
 685 */
 686 int spell_RF5_BA_POIS(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 687 {
 688     int dam;
 689
 690     monspell_message(m_idx, t_idx,
 691         _("%^sが何かをつぶやいた。", "%^s mumbles."),
 692         _("%^sが悪臭雲の呪文を唱えた。", "%^s casts a stinking cloud."),
 693         _("%^sが%sに向かって悪臭雲の呪文を唱えた。", "%^s casts a stinking cloud at %s."),
 694         TARGET_TYPE);
 695
 696     dam = monspell_damage((MS_BALL_POIS), m_idx, DAM_ROLL);
 697     breath(y, x, m_idx, GF_POIS, dam, 2, FALSE, MS_BALL_POIS, TARGET_TYPE);
 698     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 699         update_smart_learn(m_idx, DRS_POIS);
 700
 701     return dam;
 702 }
 703
 704 /*!
 705 * @brief RF5_BA_NETHの処理。地獄球。 /
 706 * @param y 対象の地点のy座標
 707 * @param x 対象の地点のx座標
 708 * @param m_idx 呪文を唱えるモンスターID
 709 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 710 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 711 * @return ダメージ量を返す。
 712 */
 713 int spell_RF5_BA_NETH(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 714 {
 715     int dam;
 716
 717     monspell_message(m_idx, t_idx,
 718         _("%^sが何かをつぶやいた。", "%^s mumbles."),
 719         _("%^sが地獄球の呪文を唱えた。", "%^s casts a nether ball."),
 720         _("%^sが%sに向かって地獄球の呪文を唱えた。", "%^s casts a nether ball at %s."),
 721         TARGET_TYPE);
 722
 723     dam = monspell_damage((MS_BALL_NETHER), m_idx, DAM_ROLL);
 724     breath(y, x, m_idx, GF_NETHER, dam, 2, FALSE, MS_BALL_NETHER, TARGET_TYPE);
 725     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 726         update_smart_learn(m_idx, DRS_NETH);
 727
 728     return dam;
 729 }
 730
 731 /*!
 732 * @brief RF5_BA_WATEの処理。ウォーター・ボール。 /
 733 * @param y 対象の地点のy座標
 734 * @param x 対象の地点のx座標
 735 * @param m_idx 呪文を唱えるモンスターID
 736 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 737 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 738 * @return ダメージ量を返す。
 739 */
 740 int spell_RF5_BA_WATE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 741 {
 742     int dam;
 743     bool known = monster_near_player(m_idx, t_idx);
 744     bool see_either = see_monster(m_idx) || see_monster(t_idx);
 745     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
 746     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
 747         char t_name[80];
 748     monster_name(t_idx, t_name);
 749
 750
 751     monspell_message(m_idx, t_idx,
 752         _("%^sが何かをつぶやいた。", "%^s mumbles."),
 753         _("%^sが流れるような身振りをした。", "%^s gestures fluidly."),
 754         _("%^sが%sに対して流れるような身振りをした。", "%^s gestures fluidly at %s."),
 755         TARGET_TYPE);
 756
 757     if (mon_to_player)
 758     {
 759         msg_format(_("あなたは渦巻きに飲み込まれた。", "You are engulfed in a whirlpool."));
 760     }
 761     else if (mon_to_mon && known && see_either && !p_ptr->blind)
 762     {
 763         msg_format(_("%^sは渦巻に飲み込まれた。", "%^s is engulfed in a whirlpool."), t_name);
 764     }
 765
 766     dam = monspell_damage((MS_BALL_WATER), m_idx, DAM_ROLL);
 767     breath(y, x, m_idx, GF_WATER, dam, 4, FALSE, MS_BALL_WATER, TARGET_TYPE);
 768     return dam;
 769 }
 770
 771 /*!
 772 * @brief RF5_BA_MANAの処理。魔力の嵐。 /
 773 * @param y 対象の地点のy座標
 774 * @param x 対象の地点のx座標
 775 * @param m_idx 呪文を唱えるモンスターID
 776 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 777 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 778 * @return ダメージ量を返す。
 779 */
 780 int spell_RF5_BA_MANA(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 781 {
 782     int dam;
 783
 784     monspell_message(m_idx, t_idx,
 785         _("%^sが何かを力強くつぶやいた。", "%^s mumbles powerfully."),
 786         _("%^sが魔力の嵐の呪文を念じた。", "%^s invokes a mana storm."),
 787         _("%^sが%sに対して魔力の嵐の呪文を念じた。", "%^s invokes a mana storm upon %s."),
 788         TARGET_TYPE);
 789
 790     dam = monspell_damage((MS_BALL_MANA), m_idx, DAM_ROLL);
 791     breath(y, x, m_idx, GF_MANA, dam, 4, FALSE, MS_BALL_MANA, TARGET_TYPE);
 792     return dam;
 793 }
 794
 795 /*!
 796 * @brief RF5_BA_DARKの処理。暗黒の嵐。 /
 797 * @param y 対象の地点のy座標
 798 * @param x 対象の地点のx座標
 799 * @param m_idx 呪文を唱えるモンスターID
 800 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 801 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 802 * @return ダメージ量を返す。
 803 */
 804 int spell_RF5_BA_DARK(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 805 {
 806     int dam;
 807
 808     monspell_message(m_idx, t_idx,
 809         _("%^sが何かを力強くつぶやいた。", "%^s mumbles powerfully."),
 810         _("%^sが暗黒の嵐の呪文を念じた。", "%^s invokes a darkness storm."),
 811         _("%^sが%sに対して暗黒の嵐の呪文を念じた。", "%^s invokes a darkness storm upon %s."),
 812         TARGET_TYPE);
 813
 814     dam = monspell_damage((MS_BALL_DARK), m_idx, DAM_ROLL);
 815     breath(y, x, m_idx, GF_DARK, dam, 4, FALSE, MS_BALL_DARK, TARGET_TYPE);
 816     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 817         update_smart_learn(m_idx, DRS_DARK);
 818
 819     return dam;
 820 }
 821
 822 /*!
 823 * @brief RF5_DRAIN_MANAの処理。魔力吸収。 /
 824 * @param y 対象の地点のy座標
 825 * @param x 対象の地点のx座標
 826 * @param m_idx 呪文を唱えるモンスターID
 827 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 828 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 829 * @return ダメージ量を返す。
 830 */
 831 int spell_RF5_DRAIN_MANA(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 832 {
 833     int dam;
 834         char m_name[80], t_name[80];
 835     monster_name(m_idx, m_name);
 836         monster_name(t_idx, t_name);
 837
 838
 839     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 840     {
 841         disturb(1, 1);
 842     }
 843     else if (TARGET_TYPE == MONSTER_TO_MONSTER && see_monster(m_idx))
 844     {
 845         /* Basic message */
 846         msg_format(_("%^sは精神エネルギーを%sから吸いとった。", "%^s draws psychic energy from %s."), m_name, t_name);
 847     }
 848
 849     dam = monspell_damage((MS_DRAIN_MANA), m_idx, DAM_ROLL);
 850     breath(y, x, m_idx, GF_DRAIN_MANA, dam, 0, FALSE, MS_DRAIN_MANA, TARGET_TYPE);
 851     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 852         update_smart_learn(m_idx, DRS_MANA);
 853
 854     return dam;
 855 }
 856
 857 /*!
 858 * @brief RF5_MIND_BLASTの処理。精神攻撃。 /
 859 * @param y 対象の地点のy座標
 860 * @param x 対象の地点のx座標
 861 * @param m_idx 呪文を唱えるモンスターID
 862 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 863 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 864 * @return ダメージ量を返す。
 865 */
 866 int spell_RF5_MIND_BLAST(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 867 {
 868     monster_type    *m_ptr = &m_list[m_idx];
 869     bool seen = (!p_ptr->blind && m_ptr->ml);
 870     int dam;
 871         char m_name[80], t_name[80];
 872     monster_name(m_idx, m_name);
 873         monster_name(t_idx, t_name);
 874
 875
 876     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 877     {
 878         disturb(1, 1);
 879         if (!seen)
 880             msg_print(_("何かがあなたの精神に念を放っているようだ。", "You feel something focusing on your mind."));
 881         else
 882             msg_format(_("%^sがあなたの瞳をじっとにらんでいる。", "%^s gazes deep into your eyes."), m_name);
 883     }
 884     else if (TARGET_TYPE == MONSTER_TO_MONSTER && see_monster(m_idx))
 885     {
 886         msg_format(_("%^sは%sをじっと睨んだ。", "%^s gazes intently at %s."), m_name, t_name);
 887     }
 888
 889     dam = monspell_damage((MS_MIND_BLAST), m_idx, DAM_ROLL);
 890     breath(y, x, m_idx, GF_MIND_BLAST, dam, 0, FALSE, MS_MIND_BLAST, TARGET_TYPE);
 891     return dam;
 892 }
 893
 894 /*!
 895 * @brief RF5_BRAIN_SMASHの処理。脳攻撃。 /
 896 * @param y 対象の地点のy座標
 897 * @param x 対象の地点のx座標
 898 * @param m_idx 呪文を唱えるモンスターID
 899 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 900 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 901 * @return ダメージ量を返す。
 902 */
 903 int spell_RF5_BRAIN_SMASH(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 904 {
 905     monster_type    *m_ptr = &m_list[m_idx];
 906     bool seen = (!p_ptr->blind && m_ptr->ml);
 907     int dam;
 908         char m_name[80], t_name[80];
 909     monster_name(m_idx, m_name);
 910         monster_name(t_idx, t_name);
 911
 912
 913     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 914     {
 915         disturb(1, 1);
 916         if (!seen)
 917             msg_print(_("何かがあなたの精神に念を放っているようだ。", "You feel something focusing on your mind."));
 918         else
 919             msg_format(_("%^sがあなたの瞳をじっとにらんでいる。", "%^s gazes deep into your eyes."), m_name);
 920     }
 921     else if (TARGET_TYPE == MONSTER_TO_MONSTER && see_monster(m_idx))
 922     {
 923         msg_format(_("%^sは%sをじっと睨んだ。", "%^s gazes intently at %s."), m_name, t_name);
 924     }
 925
 926     dam = monspell_damage((MS_BRAIN_SMASH), m_idx, DAM_ROLL);
 927     breath(y, x, m_idx, GF_BRAIN_SMASH, dam, 0, FALSE, MS_BRAIN_SMASH, TARGET_TYPE);
 928     return dam;
 929 }
 930
 931 /*!
 932 * @brief RF5_CAUSE_*のメッセージ処理関数 /
 933 * @param GF_TYPE 攻撃に使用する属性
 934 * @param dam 攻撃に使用するダメージ量
 935 * @param y 対象の地点のy座標
 936 * @param x 対象の地点のx座標
 937 * @param m_idx 呪文を唱えるモンスターID
 938 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 939 * @param msg1 対プレイヤー、盲目時メッセージ
 940 * @param msg2 対プレイヤー、非盲目時メッセージ
 941 * @param msg3 対モンスターのメッセージ
 942 * @param MS_TYPE 呪文の番号
 943 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 944 * @return ダメージ量を返す。
 945 */
 946 void spell_RF5_CAUSE(int GF_TYPE, int dam, int y, int x, int m_idx, int t_idx, cptr msg1, cptr msg2, cptr msg3, int MS_TYPE, int TARGET_TYPE)
 947 {
 948         char m_name[80], t_name[80];
 949     monster_name(m_idx, m_name);
 950         monster_name(t_idx, t_name);
 951
 952     if (TARGET_TYPE == MONSTER_TO_PLAYER)
 953     {
 954         disturb(1, 1);
 955         if (p_ptr->blind)
 956             msg_format(msg1, m_name);
 957         else
 958             msg_format(msg2, m_name);
 959     }
 960     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
 961     {
 962         if (see_monster(m_idx))
 963         {
 964             msg_format(msg3, m_name, t_name);
 965         }
 966         else
 967         {
 968             mon_fight = TRUE;
 969         }
 970     }
 971     breath(y, x, m_idx, GF_TYPE, dam, 0, FALSE, MS_TYPE, TARGET_TYPE);
 972 }
 973
 974 /*!
 975 * @brief RF5_CAUSE_1の処理。軽傷の呪い。 /
 976 * @param y 対象の地点のy座標
 977 * @param x 対象の地点のx座標
 978 * @param m_idx 呪文を唱えるモンスターID
 979 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
 980 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
 981 * @return ダメージ量を返す。
 982 */
 983 int spell_RF5_CAUSE_1(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
 984 {
 985     cptr msg1, msg2, msg3;
 986     int dam;
 987     dam = monspell_damage((MS_CAUSE_1), m_idx, DAM_ROLL);
 988
 989     msg1 = _("%^sが何かをつぶやいた。", "%^s mumbles.");
 990     msg2 = _("%^sがあなたを指さして呪った。", "%^s points at you and curses.");
 991     msg3 = _("%^sは%sを指さして呪いをかけた。", "%^s points at %s and curses.");
 992
 993     spell_RF5_CAUSE(GF_CAUSE_1, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, MS_CAUSE_1, TARGET_TYPE);
 994     return dam;
 995 }
 996
 997 /*!
 998 * @brief RF5_CAUSE_2の処理。重傷の呪い。 /
 999 * @param y 対象の地点のy座標
1000 * @param x 対象の地点のx座標
1001 * @param m_idx 呪文を唱えるモンスターID
1002 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1003 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1004 * @return ダメージ量を返す。
1005 */
1006 int spell_RF5_CAUSE_2(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1007 {
1008     cptr msg1, msg2, msg3;
1009     int dam;
1010     dam = monspell_damage((MS_CAUSE_2), m_idx, DAM_ROLL);
1011
1012     msg1 = _("%^sが何かをつぶやいた。", "%^s mumbles.");
1013     msg2 = _("%^sがあなたを指さして恐ろしげに呪った。", "%^s points at you and curses horribly.");
1014     msg3 = _("%^sは%sを指さして恐ろしげに呪いをかけた。", "%^s points at %s and curses horribly.");
1015
1016     spell_RF5_CAUSE(GF_CAUSE_2, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, MS_CAUSE_2, TARGET_TYPE);
1017     return dam;
1018 }
1019
1020 /*!
1021 * @brief RF5_CAUSE_3の処理。致命傷の呪い。 /
1022 * @param y 対象の地点のy座標
1023 * @param x 対象の地点のx座標
1024 * @param m_idx 呪文を唱えるモンスターID
1025 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1026 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1027 * @return ダメージ量を返す。
1028 */
1029 int spell_RF5_CAUSE_3(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1030 {
1031     cptr msg1, msg2, msg3;
1032     int dam;
1033     dam = monspell_damage((MS_CAUSE_3), m_idx, DAM_ROLL);
1034
1035     msg1 = _("%^sが何かを大声で叫んだ。", "%^s mumbles loudly.");
1036     msg2 = _("%^sがあなたを指さして恐ろしげに呪文を唱えた！", "%^s points at you, incanting terribly!");
1037     msg3 = _("%^sは%sを指さし、恐ろしげに呪文を唱えた！", "%^s points at %s, incanting terribly!");
1038
1039     spell_RF5_CAUSE(GF_CAUSE_3, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, MS_CAUSE_3, TARGET_TYPE);
1040     return dam;
1041 }
1042
1043 /*!
1044 * @brief RF5_CAUSE_4の処理。秘孔を突く。 /
1045 * @param y 対象の地点のy座標
1046 * @param x 対象の地点のx座標
1047 * @param m_idx 呪文を唱えるモンスターID
1048 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1049 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1050 * @return ダメージ量を返す。
1051 */
1052 int spell_RF5_CAUSE_4(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1053 {
1054     cptr msg1, msg2, msg3;
1055     int dam;
1056     dam = monspell_damage((MS_CAUSE_4), m_idx, DAM_ROLL);
1057
1058     msg1 = _("%^sが「お前は既に死んでいる」と叫んだ。", "%^s screams the word 'DIE!'");
1059     msg2 = _("%^sがあなたの秘孔を突いて「お前は既に死んでいる」と叫んだ。", "%^s points at you, screaming the word DIE!");
1060     msg3 = _("%^sが%sの秘孔を突いて、「お前は既に死んでいる」と叫んだ。", "%^s points at %s, screaming the word, 'DIE!'");
1061
1062     spell_RF5_CAUSE(GF_CAUSE_4, dam, y, x, m_idx, t_idx, msg1, msg2, msg3, MS_CAUSE_4, TARGET_TYPE);
1063     return dam;
1064 }
1065
1066 /*!
1067 * @brief RF5_BO_ACIDの処理。アシッド・ボルト。 /
1068 * @param y 対象の地点のy座標
1069 * @param x 対象の地点のx座標
1070 * @param m_idx 呪文を唱えるモンスターID
1071 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1072 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1073 * @return ダメージ量を返す。
1074 */
1075 int spell_RF5_BO_ACID(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1076 {
1077     int dam;
1078
1079     monspell_message(m_idx, t_idx,
1080         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1081         _("%^sがアシッド・ボルトの呪文を唱えた。", "%^s casts a acid bolt."),
1082         _("%sが%sに向かってアシッド・ボルトの呪文を唱えた。", "%^s casts an acid bolt at %s."),
1083         TARGET_TYPE);
1084
1085     dam = monspell_damage((MS_BOLT_ACID), m_idx, DAM_ROLL);
1086     bolt(m_idx, y, x, GF_ACID, dam, MS_BOLT_ACID, TARGET_TYPE);
1087     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1088     {
1089         update_smart_learn(m_idx, DRS_ACID);
1090         update_smart_learn(m_idx, DRS_REFLECT);
1091     }
1092     return dam;
1093 }
1094
1095 /*!
1096 * @brief RF5_BO_ELECの処理。サンダー・ボルト。 /
1097 * @param y 対象の地点のy座標
1098 * @param x 対象の地点のx座標
1099 * @param m_idx 呪文を唱えるモンスターID
1100 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1101 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1102 * @return ダメージ量を返す。
1103 */
1104 int spell_RF5_BO_ELEC(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1105 {
1106     int dam;
1107
1108     monspell_message(m_idx, t_idx,
1109         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1110         _("%^sがサンダー・ボルトの呪文を唱えた。", "%^s casts a lightning bolt."),
1111         _("%^sが%sに向かってサンダー・ボルトの呪文を唱えた。", "%^s casts a lightning bolt at %s."),
1112         TARGET_TYPE);
1113
1114     dam = monspell_damage((MS_BOLT_ELEC), m_idx, DAM_ROLL);
1115     bolt(m_idx, y, x, GF_ELEC, dam, MS_BOLT_ELEC, TARGET_TYPE);
1116     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1117     {
1118         update_smart_learn(m_idx, DRS_ELEC);
1119         update_smart_learn(m_idx, DRS_REFLECT);
1120     }
1121     return dam;
1122 }
1123
1124 /*!
1125 * @brief RF5_BO_FIREの処理。ファイア・ボルト。 /
1126 * @param y 対象の地点のy座標
1127 * @param x 対象の地点のx座標
1128 * @param m_idx 呪文を唱えるモンスターID
1129 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1130 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1131 * @return ダメージ量を返す。
1132 */
1133 int spell_RF5_BO_FIRE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1134 {
1135     int dam;
1136
1137     monspell_message(m_idx, t_idx,
1138         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1139         _("%^sがファイア・ボルトの呪文を唱えた。", "%^s casts a fire bolt."),
1140         _("%^sが%sに向かってファイア・ボルトの呪文を唱えた。", "%^s casts a fire bolt at %s."),
1141         TARGET_TYPE);
1142
1143     dam = monspell_damage((MS_BOLT_FIRE), m_idx, DAM_ROLL);
1144     bolt(m_idx, y, x, GF_FIRE, dam, MS_BOLT_FIRE, TARGET_TYPE);
1145     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1146     {
1147         update_smart_learn(m_idx, DRS_FIRE);
1148         update_smart_learn(m_idx, DRS_REFLECT);
1149     }
1150     return dam;
1151 }
1152
1153 /*!
1154 * @brief RF5_BO_COLDの処理。アイス・ボルト。 /
1155 * @param y 対象の地点のy座標
1156 * @param x 対象の地点のx座標
1157 * @param m_idx 呪文を唱えるモンスターID
1158 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1159 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1160 * @return ダメージ量を返す。
1161 */
1162 int spell_RF5_BO_COLD(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1163 {
1164     int dam;
1165
1166     monspell_message(m_idx, t_idx,
1167         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1168         _("%^sがアイス・ボルトの呪文を唱えた。", "%^s casts a frost bolt."),
1169         _("%^sが%sに向かってアイス・ボルトの呪文を唱えた。", "%^s casts a frost bolt at %s."),
1170         TARGET_TYPE);
1171
1172     dam = monspell_damage((MS_BOLT_COLD), m_idx, DAM_ROLL);
1173     bolt(m_idx, y, x, GF_COLD, dam, MS_BOLT_COLD, TARGET_TYPE);
1174     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1175     {
1176         update_smart_learn(m_idx, DRS_COLD);
1177         update_smart_learn(m_idx, DRS_REFLECT);
1178     }
1179     return dam;
1180 }
1181
1182 /*!
1183 * @brief RF5_BA_LITEの処理。スターバースト。 /
1184 * @param y 対象の地点のy座標
1185 * @param x 対象の地点のx座標
1186 * @param m_idx 呪文を唱えるモンスターID
1187 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1188 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1189 * @return ダメージ量を返す。
1190 */
1191 int spell_RF5_BA_LITE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1192 {
1193     int dam;
1194
1195     monspell_message(m_idx, t_idx,
1196         _("%^sが何かを力強くつぶやいた。", "%^s mumbles powerfully."),
1197         _("%^sがスターバーストの呪文を念じた。", "%^s invokes a starburst."),
1198         _("%^sが%sに対してスターバーストの呪文を念じた。", "%^s invokes a starburst upon %s."),
1199         TARGET_TYPE);
1200
1201     dam = monspell_damage((MS_STARBURST), m_idx, DAM_ROLL);
1202     breath(y, x, m_idx, GF_LITE, dam, 4, FALSE, MS_STARBURST, TARGET_TYPE);
1203     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1204         update_smart_learn(m_idx, DRS_LITE);
1205
1206     return dam;
1207 }
1208
1209 /*!
1210 * @brief RF5_BO_NETHの処理。地獄の矢。 /
1211 * @param y 対象の地点のy座標
1212 * @param x 対象の地点のx座標
1213 * @param m_idx 呪文を唱えるモンスターID
1214 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1215 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1216 * @return ダメージ量を返す。
1217 */
1218 int spell_RF5_BO_NETH(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1219 {
1220     int dam;
1221
1222     monspell_message(m_idx, t_idx,
1223         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1224         _("%^sが地獄の矢の呪文を唱えた。", "%^s casts a nether bolt."),
1225         _("%^sが%sに向かって地獄の矢の呪文を唱えた。", "%^s casts a nether bolt at %s."),
1226         TARGET_TYPE);
1227
1228     dam = monspell_damage((MS_BOLT_NETHER), m_idx, DAM_ROLL);
1229     bolt(m_idx, y, x, GF_NETHER, dam, MS_BOLT_NETHER, TARGET_TYPE);
1230     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1231     {
1232         update_smart_learn(m_idx, DRS_NETH);
1233         update_smart_learn(m_idx, DRS_REFLECT);
1234     }
1235     return dam;
1236 }
1237
1238 /*!
1239 * @brief RF5_BO_WATEの処理。ウォーター・ボルト。 /
1240 * @param y 対象の地点のy座標
1241 * @param x 対象の地点のx座標
1242 * @param m_idx 呪文を唱えるモンスターID
1243 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1244 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1245 * @return ダメージ量を返す。
1246 */
1247 int spell_RF5_BO_WATE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1248 {
1249     int dam;
1250
1251     monspell_message(m_idx, t_idx,
1252         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1253         _("%^sがウォーター・ボルトの呪文を唱えた。", "%^s casts a water bolt."),
1254         _("%^sが%sに向かってウォーター・ボルトの呪文を唱えた。", "%^s casts a water bolt at %s."),
1255         TARGET_TYPE);
1256
1257     dam = monspell_damage((MS_BOLT_WATER), m_idx, DAM_ROLL);
1258     bolt(m_idx, y, x, GF_WATER, dam, MS_BOLT_WATER, TARGET_TYPE);
1259     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1260     {
1261         update_smart_learn(m_idx, DRS_REFLECT);
1262     }
1263     return dam;
1264 }
1265
1266 /*!
1267 * @brief RF5_BO_MANAの処理。魔力の矢。 /
1268 * @param y 対象の地点のy座標
1269 * @param x 対象の地点のx座標
1270 * @param m_idx 呪文を唱えるモンスターID
1271 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1272 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1273 * @return ダメージ量を返す。
1274 */
1275 int spell_RF5_BO_MANA(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1276 {
1277     int dam;
1278
1279     monspell_message(m_idx, t_idx,
1280         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1281         _("%^sが魔力の矢の呪文を唱えた。", "%^s casts a mana bolt."),
1282         _("%^sが%sに向かって魔力の矢の呪文を唱えた。", "%^s casts a mana bolt at %s."),
1283         TARGET_TYPE);
1284
1285     dam = monspell_damage((MS_BOLT_MANA), m_idx, DAM_ROLL);
1286     bolt(m_idx, y, x, GF_MANA, dam, MS_BOLT_MANA, TARGET_TYPE);
1287     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1288     {
1289         update_smart_learn(m_idx, DRS_REFLECT);
1290     }
1291     return dam;
1292 }
1293
1294 /*!
1295 * @brief RF5_BO_PLASの処理。プラズマ・ボルト。 /
1296 * @param y 対象の地点のy座標
1297 * @param x 対象の地点のx座標
1298 * @param m_idx 呪文を唱えるモンスターID
1299 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1300 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1301 * @return ダメージ量を返す。
1302 */
1303 int spell_RF5_BO_PLAS(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1304 {
1305     int dam;
1306
1307     monspell_message(m_idx, t_idx,
1308         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1309         _("%^sがプラズマ・ボルトの呪文を唱えた。", "%^s casts a plasma bolt."),
1310         _("%^sが%sに向かってプラズマ・ボルトの呪文を唱えた。", "%^s casts a plasma bolt at %s."),
1311         TARGET_TYPE);
1312
1313     dam = monspell_damage((MS_BOLT_PLASMA), m_idx, DAM_ROLL);
1314     bolt(m_idx, y, x, GF_PLASMA, dam, MS_BOLT_PLASMA, TARGET_TYPE);
1315     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1316     {
1317         update_smart_learn(m_idx, DRS_REFLECT);
1318     }
1319     return dam;
1320 }
1321
1322 /*!
1323 * @brief RF5_BO_ICEEの処理。極寒の矢。 /
1324 * @param y 対象の地点のy座標
1325 * @param x 対象の地点のx座標
1326 * @param m_idx 呪文を唱えるモンスターID
1327 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1328 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1329 * @return ダメージ量を返す。
1330 */
1331 int spell_RF5_BO_ICEE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1332 {
1333     int dam;
1334
1335     monspell_message(m_idx, t_idx,
1336         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1337         _("%^sが極寒の矢の呪文を唱えた。", "%^s casts an ice bolt."),
1338         _("%^sが%sに向かって極寒の矢の呪文を唱えた。", "%^s casts an ice bolt at %s."),
1339         TARGET_TYPE);
1340
1341     dam = monspell_damage((MS_BOLT_ICE), m_idx, DAM_ROLL);
1342     bolt(m_idx, y, x, GF_ICE, dam, MS_BOLT_ICE, TARGET_TYPE);
1343     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1344     {
1345         update_smart_learn(m_idx, DRS_COLD);
1346         update_smart_learn(m_idx, DRS_REFLECT);
1347     }
1348     return dam;
1349 }
1350
1351 /*!
1352 * @brief RF5_MISSILEの処理。マジック・ミサイル。 /
1353 * @param y 対象の地点のy座標
1354 * @param x 対象の地点のx座標
1355 * @param m_idx 呪文を唱えるモンスターID
1356 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1357 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1358 * @return ダメージ量を返す。
1359 */
1360 int spell_RF5_MISSILE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1361 {
1362     int dam;
1363
1364     monspell_message(m_idx, t_idx,
1365         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1366         _("%^sがマジック・ミサイルの呪文を唱えた。", "%^s casts a magic missile."),
1367         _("%^sが%sに向かってマジック・ミサイルの呪文を唱えた。", "%^s casts a magic missile at %s."),
1368         TARGET_TYPE);
1369
1370     dam = monspell_damage((MS_MAGIC_MISSILE), m_idx, DAM_ROLL);
1371     bolt(m_idx, y, x, GF_MISSILE, dam, MS_MAGIC_MISSILE, TARGET_TYPE);
1372     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1373     {
1374         update_smart_learn(m_idx, DRS_REFLECT);
1375     }
1376     return dam;
1377 }
1378
1379 /*!
1380 * @brief 状態異常呪文のメッセージ処理関数。 /
1381 * @param m_idx 呪文を唱えるモンスターID
1382 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1383 * @param msg1 対プレイヤーなら盲目時メッセージ。対モンスターなら通常時メッセージ。
1384 * @param msg2 対プレイヤーなら非盲目時メッセージ。対モンスターなら耐性有メッセージ。
1385 * @param msg3 対プレイヤーなら耐性有メッセージ。対モンスターなら抵抗時メッセージ。
1386 * @param msg4 対プレイヤーなら抵抗時メッセージ。対モンスターなら成功時メッセージ。
1387 * @param resist 耐性の有無を判別するフラグ
1388 * @param saving_throw 抵抗に成功したか判別するフラグ
1389 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1390 */
1391 void spell_badstatus_message(int m_idx, int t_idx, cptr msg1, cptr msg2, cptr msg3, cptr msg4, bool resist, bool saving_throw, int TARGET_TYPE)
1392 {
1393     bool see_either = see_monster(m_idx) || see_monster(t_idx);
1394     bool see_t = see_monster(t_idx);
1395     bool known = monster_near_player(m_idx, t_idx);
1396     char m_name[80], t_name[80];
1397     monster_name(m_idx, m_name);
1398     monster_name(t_idx, t_name);
1399
1400     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1401     {
1402         disturb(1, 1);
1403         if (p_ptr->blind)
1404             msg_format(msg1, m_name);
1405         else
1406             msg_format(msg2, m_name);
1407
1408         if (resist)
1409         {
1410             msg_print(msg3);
1411         }
1412         else if (saving_throw)
1413         {
1414             msg_print(msg4);
1415         }
1416     }
1417     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
1418     {
1419         if (known)
1420         {
1421             if (see_either)
1422             {
1423                 msg_format(msg1, m_name, t_name);
1424             }
1425             else
1426             {
1427                 mon_fight = TRUE;
1428             }
1429         }
1430
1431         if (resist)
1432         {
1433             if (see_t) msg_format(msg2, t_name);
1434         }
1435         else if (saving_throw)
1436         {
1437             if (see_t) msg_format(msg3, t_name);
1438         }
1439         else
1440         {
1441             if (see_t) msg_format(msg4, t_name);
1442         }
1443         monster_wakeup(t_idx);
1444     }
1445 }
1446
1447 /*!
1448  * @brief RF5_SCAREの処理。恐怖。 /
1449  * @param m_idx 呪文を唱えるモンスターID
1450  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1451  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1452  */
1453 void spell_RF5_SCARE(int m_idx, int t_idx, int TARGET_TYPE)
1454 {
1455     monster_type    *t_ptr = &m_list[t_idx];
1456     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
1457     int rlev = monster_level_idx(m_idx);
1458     bool resist, saving_throw;
1459
1460     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1461     {
1462         resist = p_ptr->resist_fear;
1463         saving_throw = (randint0(100 + rlev / 2) < p_ptr->skill_sav);
1464         spell_badstatus_message(m_idx, t_idx,
1465             _("%^sが何かをつぶやくと、恐ろしげな音が聞こえた。", "%^s mumbles, and you hear scary noises."),
1466             _("%^sが恐ろしげな幻覚を作り出した。", "%^s casts a fearful illusion."),
1467             _("しかし恐怖に侵されなかった。", "You refuse to be frightened."),
1468             _("しかし恐怖に侵されなかった。", "You refuse to be frightened."),
1469             resist, saving_throw, TARGET_TYPE);
1470
1471         if (!resist && !saving_throw)
1472         {
1473             (void)set_afraid(p_ptr->afraid + randint0(4) + 4);
1474         }
1475         learn_spell(MS_SCARE);
1476         update_smart_learn(m_idx, DRS_FEAR);
1477     }
1478     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
1479     {
1480         resist = tr_ptr->flags3 & RF3_NO_FEAR;
1481         saving_throw = (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
1482
1483         spell_badstatus_message(m_idx, t_idx,
1484             _("%^sが恐ろしげな幻覚を作り出した。", "%^s casts a fearful illusion in front of %s."),
1485             _("%^sは恐怖を感じない。", "%^s refuses to be frightened."),
1486             _("%^sは恐怖を感じない。", "%^s refuses to be frightened."),
1487             _("%^sは恐怖して逃げ出した！", "%^s flees in terror!"),
1488             resist, saving_throw, TARGET_TYPE);
1489
1490         if (!resist && !saving_throw)
1491         {
1492             set_monster_monfear(t_idx, MON_MONFEAR(t_ptr) + randint0(4) + 4);
1493         }
1494     }
1495 }
1496
1497 /*!
1498  * @brief RF5_BLINDの処理。盲目。 /
1499  * @param m_idx 呪文を唱えるモンスターID
1500  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1501  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1502  */
1503 void spell_RF5_BLIND(int m_idx, int t_idx, int TARGET_TYPE)
1504 {
1505     monster_type    *t_ptr = &m_list[t_idx];
1506     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
1507     int rlev = monster_level_idx(m_idx);
1508     bool resist, saving_throw;
1509
1510     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1511     {
1512         resist = p_ptr->resist_blind;
1513         saving_throw = (randint0(100 + rlev / 2) < p_ptr->skill_sav);
1514         spell_badstatus_message(m_idx, t_idx,
1515             _("%^sが何かをつぶやいた。", "%^s mumbles."),
1516             _("%^sが呪文を唱えてあなたの目をくらました！", "%^s casts a spell, burning your eyes!"),
1517             _("しかし効果がなかった！", "You are unaffected!"),
1518             _("しかし効力を跳ね返した！", "You resist the effects!"),
1519             resist, saving_throw, TARGET_TYPE);
1520
1521         if (!resist && !saving_throw)
1522         {
1523             (void)set_blind(12 + randint0(4));
1524         }
1525         learn_spell(MS_BLIND);
1526         update_smart_learn(m_idx, DRS_BLIND);
1527     }
1528     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
1529     {
1530         cptr msg1;
1531         char t_name[80];
1532         monster_name(t_idx, t_name);
1533
1534         if (streq(t_name, "it"))
1535         {
1536             msg1 = _("%sは呪文を唱えて%sの目を焼き付かせた。", "%^s casts a spell, burning %ss eyes.");
1537         }
1538         else
1539         {
1540             msg1 = _("%sは呪文を唱えて%sの目を焼き付かせた。", "%^s casts a spell, burning %s's eyes.");
1541         }
1542
1543         resist = tr_ptr->flags3 & RF3_NO_CONF;
1544         saving_throw = (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
1545
1546         spell_badstatus_message(m_idx, t_idx,
1547             msg1,
1548             _("%^sには効果がなかった。", "%^s is unaffected."),
1549             _("%^sには効果がなかった。", "%^s is unaffected."),
1550             _("%^sは目が見えなくなった！ ", "%^s is blinded!"),
1551             resist, saving_throw, TARGET_TYPE);
1552
1553         if (!resist && !saving_throw)
1554         {
1555             (void)set_monster_confused(t_idx, MON_CONFUSED(t_ptr) + 12 + randint0(4));
1556         }
1557     }
1558 }
1559
1560 /*!
1561  * @brief RF5_CONFの処理。混乱。/
1562  * @param m_idx 呪文を唱えるモンスターID
1563  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1564  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1565  */
1566 void spell_RF5_CONF(int m_idx, int t_idx, int TARGET_TYPE)
1567 {
1568     monster_type    *t_ptr = &m_list[t_idx];
1569     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
1570     int rlev = monster_level_idx(m_idx);
1571     bool resist, saving_throw;
1572
1573     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1574     {
1575         resist = p_ptr->resist_conf;
1576         saving_throw = (randint0(100 + rlev / 2) < p_ptr->skill_sav);
1577         spell_badstatus_message(m_idx, t_idx,
1578             _("%^sが何かをつぶやくと、頭を悩ます音がした。", "%^s mumbles, and you hear puzzling noises."),
1579             _("%^sが誘惑的な幻覚を作り出した。", "%^s creates a mesmerising illusion."),
1580             _("しかし幻覚にはだまされなかった。", "You disbelieve the feeble spell."),
1581             _("しかし幻覚にはだまされなかった。", "You disbelieve the feeble spell."),
1582             resist, saving_throw, TARGET_TYPE);
1583
1584         if (!resist && !saving_throw)
1585         {
1586             (void)set_confused(p_ptr->confused + randint0(4) + 4);
1587         }
1588         learn_spell(MS_CONF);
1589         update_smart_learn(m_idx, DRS_CONF);
1590     }
1591     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
1592     {
1593         resist = tr_ptr->flags3 & RF3_NO_CONF;
1594         saving_throw = (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
1595
1596         spell_badstatus_message(m_idx, t_idx,
1597             _("%^sが%sの前に幻惑的な幻をつくり出した。", "%^s casts a mesmerizing illusion in front of %s."),
1598             _("%^sは惑わされなかった。", "%^s disbelieves the feeble spell."),
1599             _("%^sは惑わされなかった。", "%^s disbelieves the feeble spell."),
1600             _("%^sは混乱したようだ。", "%^s seems confused."),
1601             resist, saving_throw, TARGET_TYPE);
1602
1603         if (!resist && !saving_throw)
1604         {
1605             (void)set_monster_confused(t_idx, MON_CONFUSED(t_ptr) + 12 + randint0(4));
1606         }
1607     }
1608 }
1609
1610 /*!
1611  * @brief RF5_SLOWの処理。減速。 /
1612  * @param m_idx 呪文を唱えるモンスターID
1613  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1614  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1615  */
1616 void spell_RF5_SLOW(int m_idx, int t_idx, int TARGET_TYPE)
1617 {
1618     monster_type    *t_ptr = &m_list[t_idx];
1619     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
1620     int rlev = monster_level_idx(m_idx);
1621     bool resist, saving_throw;
1622
1623     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1624     {
1625         resist = p_ptr->resist_conf;
1626         saving_throw = (randint0(100 + rlev / 2) < p_ptr->skill_sav);
1627         spell_badstatus_message(m_idx, t_idx,
1628             _("%^sがあなたの筋力を吸い取ろうとした！", "%^s drains power from your muscles!"),
1629             _("%^sがあなたの筋力を吸い取ろうとした！", "%^s drains power from your muscles!"),
1630             _("しかし効果がなかった！", "You are unaffected!"),
1631             _("しかし効力を跳ね返した！", "You resist the effects!"),
1632             resist, saving_throw, TARGET_TYPE);
1633
1634         if (!resist && !saving_throw)
1635         {
1636             (void)set_slow(p_ptr->slow + randint0(4) + 4, FALSE);
1637         }
1638         learn_spell(MS_SLOW);
1639         update_smart_learn(m_idx, DRS_FREE);
1640     }
1641     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
1642     {
1643         cptr msg1;
1644         char t_name[80];
1645         monster_name(t_idx, t_name);
1646
1647         if (streq(t_name, "it"))
1648         {
1649             msg1 = _("%sが%sの筋肉から力を吸いとった。", "%^s drains power from %ss muscles.");
1650         }
1651         else
1652         {
1653             msg1 = _("%sが%sの筋肉から力を吸いとった。", "%^s drains power from %s's muscles.");
1654         }
1655
1656         resist = tr_ptr->flags1 & RF1_UNIQUE;
1657         saving_throw = (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
1658
1659         spell_badstatus_message(m_idx, t_idx,
1660             msg1,
1661             _("%^sには効果がなかった。", "%^s is unaffected."),
1662             _("%^sには効果がなかった。", "%^s is unaffected."),
1663             _("%sの動きが遅くなった。", "%^s starts moving slower."),
1664             resist, saving_throw, TARGET_TYPE);
1665
1666         if (!resist && !saving_throw)
1667         {
1668             set_monster_slow(t_idx, MON_SLOW(t_ptr) + 50);
1669         }
1670     }
1671 }
1672
1673 /*!
1674  * @brief RF5_HOLDの処理。麻痺。 /
1675  * @param m_idx 呪文を唱えるモンスターID
1676  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1677  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1678  */
1679 void spell_RF5_HOLD(int m_idx, int t_idx, int TARGET_TYPE)
1680 {
1681     monster_type    *t_ptr = &m_list[t_idx];
1682     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
1683     int rlev = monster_level_idx(m_idx);
1684     bool resist, saving_throw;
1685
1686     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1687     {
1688         resist = p_ptr->free_act;
1689         saving_throw = (randint0(100 + rlev / 2) < p_ptr->skill_sav);
1690         spell_badstatus_message(m_idx, t_idx,
1691             _("%^sが何かをつぶやいた。", "%^s mumbles."),
1692             _("%^sがあなたの目をじっと見つめた！", "%^s stares deep into your eyes!"),
1693             _("しかし効果がなかった！", "You are unaffected!"),
1694             _("しかし効力を跳ね返した！", "You resist the effects!"),
1695             resist, saving_throw, TARGET_TYPE);
1696
1697         if (!resist && !saving_throw)
1698         {
1699             (void)set_paralyzed(p_ptr->paralyzed + randint0(4) + 4);
1700         }
1701         learn_spell(MS_SLEEP);
1702         update_smart_learn(m_idx, DRS_FREE);
1703     }
1704     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
1705     {
1706         resist = (tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flags3 & RF3_NO_STUN);
1707         saving_throw = (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
1708
1709         spell_badstatus_message(m_idx, t_idx,
1710             _("%^sは%sをじっと見つめた。", "%^s stares intently at %s."),
1711             _("%^sには効果がなかった。", "%^s is unaffected."),
1712             _("%^sには効果がなかった。", "%^s is unaffected."),
1713             _("%^sは麻痺した！", "%^s is paralyzed!"),
1714             resist, saving_throw, TARGET_TYPE);
1715
1716         if (!resist && !saving_throw)
1717         {
1718             (void)set_monster_stunned(t_idx, MON_STUNNED(t_ptr) + randint1(4) + 4);
1719         }
1720     }
1721 }
1722
1723 /*!
1724 * @brief RF6_HASTEの処理。加速。 /
1725 * @param m_idx 呪文を唱えるモンスターID
1726 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1727 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1728 */
1729 void spell_RF6_HASTE(int m_idx, int t_idx, int TARGET_TYPE)
1730 {
1731     bool see_m = see_monster(m_idx);
1732     monster_type    *m_ptr = &m_list[m_idx];
1733         char m_name[80];
1734     monster_name(m_idx, m_name);
1735
1736     monspell_message_base(m_idx, t_idx,
1737         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1738         _("%^sが自分の体に念を送った。", "%^s concentrates on %s body."),
1739         _("%^sが自分の体に念を送った。", "%^s concentrates on %s body."),
1740         _("%^sが自分の体に念を送った。", "%^s concentrates on %s body."),
1741         p_ptr->blind, TARGET_TYPE);
1742
1743     /* Allow quick speed increases to base+10 */
1744     if (set_monster_fast(m_idx, MON_FAST(m_ptr) + 100))
1745     {
1746         if (TARGET_TYPE == MONSTER_TO_PLAYER ||
1747             (TARGET_TYPE == MONSTER_TO_MONSTER && see_m))
1748             msg_format(_("%^sの動きが速くなった。", "%^s starts moving faster."), m_name);
1749     }
1750 }
1751
1752 /*!
1753 * @brief RF6_HAND_DOOMの処理。破滅の手。 /
1754 * @param y 対象の地点のy座標
1755 * @param x 対象の地点のx座標
1756 * @param m_idx 呪文を唱えるモンスターID
1757 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1758 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1759 * @return ダメージ量を返す。
1760 */
1761 int spell_RF6_HAND_DOOM(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
1762 {
1763     int dam;
1764
1765     simple_monspell_message(m_idx, t_idx,
1766         _("%^sが<破滅の手>を放った！", "%^s invokes the Hand of Doom!"),
1767         _("%^sが%sに<破滅の手>を放った！", "%^s invokes the Hand of Doom upon %s!"),
1768         TARGET_TYPE);
1769
1770     if (TARGET_TYPE == MONSTER_TO_PLAYER)
1771     {
1772         dam = monspell_damage((MS_HAND_DOOM), m_idx, DAM_ROLL);
1773         breath(y, x, m_idx, GF_HAND_DOOM, dam, 0, FALSE, MS_HAND_DOOM, MONSTER_TO_PLAYER);
1774     }
1775     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
1776     {
1777         dam = 20; /* Dummy power */
1778         breath(y, x, m_idx, GF_HAND_DOOM, dam, 0, FALSE, MS_HAND_DOOM, MONSTER_TO_MONSTER);
1779     }
1780     return dam;
1781 }
1782
1783 /*!
1784 * @brief RF6_HEALの処理。治癒。 /
1785 * @param m_idx 呪文を唱えるモンスターID
1786 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1787 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1788 */
1789 void spell_RF6_HEAL(int m_idx, int t_idx, int TARGET_TYPE)
1790 {
1791     monster_type    *m_ptr = &m_list[m_idx];
1792     int rlev = monster_level_idx(m_idx);
1793     bool seen = (!p_ptr->blind && m_ptr->ml);
1794         char m_name[80];
1795     monster_name(m_idx, m_name);
1796
1797     disturb(1, 1);
1798
1799     /* Message */
1800     monspell_message_base(m_idx, t_idx,
1801         _("%^sが何かをつぶやいた。", "%^s mumbles."),
1802         _("%^sは自分の傷に念を集中した。", "%^s concentrates on %s wounds."),
1803         _("%^sが自分の傷に集中した。", "%^s concentrates on %s wounds."),
1804         _("%^sは自分の傷に念を集中した。", "%^s concentrates on %s wounds."),
1805         p_ptr->blind, TARGET_TYPE);
1806
1807     /* Heal some */
1808     m_ptr->hp += (rlev * 6);
1809
1810     /* Fully healed */
1811     if (m_ptr->hp >= m_ptr->maxhp)
1812     {
1813         /* Fully healed */
1814         m_ptr->hp = m_ptr->maxhp;
1815
1816         /* Message */
1817         monspell_message_base(m_idx, t_idx,
1818             _("%^sは完全に治ったようだ！", "%^s sounds completely healed!"),
1819             _("%^sは完全に治ったようだ！", "%^s sounds completely healed!"),
1820             _("%^sは完全に治った！", "%^s looks completely healed!"),
1821             _("%^sは完全に治った！", "%^s looks completely healed!"),
1822             !seen, TARGET_TYPE);
1823     }
1824
1825     /* Partially healed */
1826     else
1827     {
1828         /* Message */
1829         monspell_message_base(m_idx, t_idx,
1830             _("%^sは体力を回復したようだ。", "%^s sounds healthier."),
1831             _("%^sは体力を回復したようだ。", "%^s sounds healthier."),
1832             _("%^sは体力を回復したようだ。", "%^s looks healthier."),
1833             _("%^sは体力を回復したようだ。", "%^s looks healthier."),
1834             !seen, TARGET_TYPE);
1835     }
1836
1837     /* Redraw (later) if needed */
1838     if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
1839     if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
1840
1841     /* Cancel fear */
1842     if (MON_MONFEAR(m_ptr))
1843     {
1844         /* Cancel fear */
1845         (void)set_monster_monfear(m_idx, 0);
1846
1847         /* Message */
1848         if (see_monster(m_idx))
1849             msg_format(_("%^sは勇気を取り戻した。", "%^s recovers %s courage."), m_name);
1850     }
1851 }
1852
1853 /*!
1854 * @brief RF6_INVULNERの処理。無敵。 /
1855 * @param m_idx 呪文を唱えるモンスターID
1856 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
1857 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1858 */
1859 void spell_RF6_INVULNER(int m_idx, int t_idx, int TARGET_TYPE)
1860 {
1861     monster_type    *m_ptr = &m_list[m_idx];
1862     bool seen = (!p_ptr->blind && m_ptr->ml);
1863
1864     /* Message */
1865         monspell_message_base(m_idx, t_idx,
1866             _("%^sが何かを力強くつぶやいた。", "%^s mumbles powerfully."),
1867             _("%^sが何かを力強くつぶやいた。", "%^s mumbles powerfully."),
1868             _("%sは無傷の球の呪文を唱えた。", "%^s casts a Globe of Invulnerability."),
1869             _("%sは無傷の球の呪文を唱えた。", "%^s casts a Globe of Invulnerability."),
1870             !seen, TARGET_TYPE);
1871
1872     if (!MON_INVULNER(m_ptr)) (void)set_monster_invulner(m_idx, randint1(4) + 4, FALSE);
1873 }
1874
1875 /*!
1876 * @brief RF6_BLINKの処理。ショート・テレポート。 /
1877 * @param m_idx 呪文を唱えるモンスターID
1878 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1879 */
1880 void spell_RF6_BLINK(int m_idx, int TARGET_TYPE)
1881 {
1882         char m_name[80];
1883     monster_name(m_idx, m_name);
1884
1885         if (TARGET_TYPE==MONSTER_TO_PLAYER)
1886                 disturb(1, 1);
1887
1888     if (teleport_barrier(m_idx))
1889     {
1890                 if(see_monster(m_idx))
1891                 msg_format(_("魔法のバリアが%^sのテレポートを邪魔した。",
1892                                                  "Magic barrier obstructs teleporting of %^s."), m_name);
1893     }
1894     else
1895     {
1896                 if(see_monster(m_idx))
1897                 msg_format(_("%^sが瞬時に消えた。", "%^s blinks away."), m_name);
1898
1899         teleport_away(m_idx, 10, 0L);
1900
1901                 if (TARGET_TYPE==MONSTER_TO_PLAYER)
1902                 p_ptr->update |= (PU_MONSTERS);
1903     }
1904 }
1905
1906 /*!
1907 * @brief RF6_TPORTの処理。テレポート。 /
1908 * @param m_idx 呪文を唱えるモンスターID
1909 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
1910 */
1911 void spell_RF6_TPORT(int m_idx, int TARGET_TYPE)
1912 {
1913         char m_name[80];
1914     monster_name(m_idx, m_name);
1915
1916         if (TARGET_TYPE==MONSTER_TO_PLAYER)
1917                 disturb(1, 1);
1918     if (teleport_barrier(m_idx))
1919     {
1920                 if(see_monster(m_idx))
1921                         msg_format(_("魔法のバリアが%^sのテレポートを邪魔した。",
1922                                                  "Magic barrier obstructs teleporting of %^s."), m_name);
1923     }
1924     else
1925     {
1926                 if(see_monster(m_idx))
1927                         msg_format(_("%^sがテレポートした。", "%^s teleports away."), m_name);
1928
1929         teleport_away_followable(m_idx);
1930     }
1931 }
1932
1933 /*!
1934 * @brief RF6_WORLDの処理。時を止める。 /
1935 * @param m_idx 呪文を唱えるモンスターID
1936 */
1937 int spell_RF6_WORLD(int m_idx)
1938 {
1939     monster_type    *m_ptr = &m_list[m_idx];
1940     int who = 0;
1941         char m_name[80];
1942     monster_name(m_idx, m_name);
1943
1944     disturb(1, 1);
1945     if (m_ptr->r_idx == MON_DIO) who = 1;
1946     else if (m_ptr->r_idx == MON_WONG) who = 3;
1947     if (!process_the_world(randint1(2) + 2, who, TRUE)) return (FALSE);
1948     return who;
1949 }
1950
1951 /*!
1952 * @brief バーノール・ルパートのRF6_SPECIALの処理。分裂・合体。 /
1953 * @param m_idx 呪文を唱えるモンスターID
1954 */
1955 int spell_RF6_SPECIAL_BANORLUPART(int m_idx)
1956 {
1957     monster_type    *m_ptr = &m_list[m_idx];
1958         int dummy_hp, dummy_maxhp, k;
1959         int dummy_y = m_ptr->fy;
1960     int dummy_x = m_ptr->fx;
1961     u32b mode = 0L;
1962
1963         switch(m_ptr->r_idx)
1964         {
1965                 case MON_BANORLUPART:
1966                         dummy_hp = (m_ptr->hp + 1) / 2;
1967                         dummy_maxhp = m_ptr->maxhp / 2;
1968
1969                         if (p_ptr->inside_arena || p_ptr->inside_battle || !summon_possible(m_ptr->fy, m_ptr->fx))
1970                                 return -1;
1971
1972                         delete_monster_idx(cave[m_ptr->fy][m_ptr->fx].m_idx);
1973                         summon_named_creature(0, dummy_y, dummy_x, MON_BANOR, mode);
1974                         m_list[hack_m_idx_ii].hp = dummy_hp;
1975                         m_list[hack_m_idx_ii].maxhp = dummy_maxhp;
1976                         summon_named_creature(0, dummy_y, dummy_x, MON_LUPART, mode);
1977                         m_list[hack_m_idx_ii].hp = dummy_hp;
1978                         m_list[hack_m_idx_ii].maxhp = dummy_maxhp;
1979
1980                         msg_print(_("『バーノール・ルパート』が分裂した！","Banor=Rupart splits in two person!"));
1981                         break;
1982
1983         case MON_BANOR:
1984         case MON_LUPART:
1985             dummy_hp = 0;
1986             dummy_maxhp = 0;
1987
1988             if (!r_info[MON_BANOR].cur_num || !r_info[MON_LUPART].cur_num)
1989                                 return -1;
1990
1991             for (k = 1; k < m_max; k++)
1992             {
1993                 if (m_list[k].r_idx == MON_BANOR || m_list[k].r_idx == MON_LUPART)
1994                 {
1995                     dummy_hp += m_list[k].hp;
1996                     dummy_maxhp += m_list[k].maxhp;
1997                     if (m_list[k].r_idx != m_ptr->r_idx)
1998                     {
1999                         dummy_y = m_list[k].fy;
2000                         dummy_x = m_list[k].fx;
2001                     }
2002                     delete_monster_idx(k);
2003                 }
2004             }
2005             summon_named_creature(0, dummy_y, dummy_x, MON_BANORLUPART, mode);
2006             m_list[hack_m_idx_ii].hp = dummy_hp;
2007             m_list[hack_m_idx_ii].maxhp = dummy_maxhp;
2008
2009             msg_print(_("『バーノール』と『ルパート』が合体した！", "Banor and Rupart combine into one!"));
2010             break;
2011         }
2012         return 0;
2013 }
2014
2015 /*!
2016 * @brief ロレントのRF6_SPECIALの処理。手榴弾の召喚。 /
2017 * @param y 対象の地点のy座標
2018 * @param x 対象の地点のx座標
2019 * @param m_idx 呪文を唱えるモンスターID
2020 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2021 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2022 * @return ダメージ量を返す。
2023 */
2024 int spell_RF6_SPECIAL_ROLENTO(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2025 {
2026         int count = 0, k;
2027     int num = 1 + randint1(3);
2028     u32b mode = 0L;
2029
2030         monspell_message(m_idx, t_idx,
2031                 _("%^sが何か大量に投げた。", "%^s spreads something."),
2032                 _("%^sは手榴弾をばらまいた。", "%^s throws some hand grenades."),
2033         _("%^sは手榴弾をばらまいた。", "%^s throws some hand grenades."),
2034         TARGET_TYPE);
2035
2036         for (k = 0; k < num; k++)
2037         {
2038                 count += summon_named_creature(m_idx, y, x, MON_SHURYUUDAN, mode);
2039         }
2040
2041         if (p_ptr->blind && count)
2042                 msg_print(_("多くのものが間近にばらまかれる音がする。", "You hear many things are scattered nearby."));
2043
2044         return 0;
2045 }
2046
2047 /*!
2048 * @brief BシンボルのRF6_SPECIALの処理。投げ落とす攻撃。 /
2049 * @param y 対象の地点のy座標
2050 * @param x 対象の地点のx座標
2051 * @param m_idx 呪文を唱えるモンスターID
2052 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2053 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2054 * @return ダメージ量を返す。
2055 */
2056 int spell_RF6_SPECIAL_B(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2057 {
2058         int dam;
2059     monster_type    *m_ptr = &m_list[m_idx];
2060     monster_type    *t_ptr = &m_list[t_idx];
2061     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
2062         bool monster_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2063         bool monster_to_monster = (TARGET_TYPE == MONSTER_TO_MONSTER);
2064     bool direct = player_bold(y, x);
2065         char m_name[80];
2066     monster_name(m_idx, m_name);
2067
2068         disturb(1, 1);
2069         if (one_in_(3) || !direct)
2070         {
2071                 simple_monspell_message(m_idx, t_idx,
2072                         _("%^sは突然視界から消えた!", "%^s suddenly go out of your sight!"),
2073                         _("%^sは突然急上昇して視界から消えた!", "%^s suddenly go out of your sight!"),
2074                         TARGET_TYPE);
2075
2076                 teleport_away(m_idx, 10, TELEPORT_NONMAGICAL);
2077                 p_ptr->update |= (PU_MONSTERS);
2078         }
2079         else
2080         {
2081                 int get_damage = 0;
2082                 bool fear; /* dummy */
2083
2084                 simple_monspell_message(m_idx, t_idx,
2085                         _("%^sがあなたを掴んで空中から投げ落とした。", "%^s holds you, and drops from the sky."),
2086                         _("%^sが%sを掴んで空中から投げ落とした。", "%^s holds %s, and drops from the sky."),
2087                         TARGET_TYPE);
2088
2089                 dam = damroll(4, 8);
2090
2091                 if (monster_to_player || t_idx == p_ptr->riding)
2092                         teleport_player_to(m_ptr->fy, m_ptr->fx, TELEPORT_NONMAGICAL | TELEPORT_PASSIVE);
2093                 else
2094                         teleport_monster_to(t_idx, m_ptr->fy, m_ptr->fx, 100, TELEPORT_NONMAGICAL | TELEPORT_PASSIVE);
2095
2096                 sound(SOUND_FALL);
2097
2098                 if ((monster_to_player && p_ptr->levitation) ||
2099                         (monster_to_monster && (tr_ptr->flags7 & RF7_CAN_FLY)))
2100                 {
2101                         simple_monspell_message(m_idx, t_idx,
2102                                 _("あなたは静かに着地した。", "You float gently down to the ground."),
2103                                 _("%^sは静かに着地した。", "%^s floats gently down to the ground."),
2104                                 TARGET_TYPE);
2105                 }
2106                 else
2107                 {
2108                         simple_monspell_message(m_idx, t_idx,
2109                                 _("あなたは地面に叩きつけられた。", "You crashed into the ground."),
2110                                 _("%^sは地面に叩きつけられた。", "%^s crashed into the ground."),
2111                                 TARGET_TYPE);
2112                         dam += damroll(6, 8);
2113                 }
2114
2115                 if(monster_to_player ||
2116                    (monster_to_monster && p_ptr->riding == t_idx))
2117                 {
2118                         /* Mega hack -- this special action deals damage to the player. Therefore the code of "eyeeye" is necessary.
2119                         -- henkma
2120                         */
2121                         get_damage = take_hit(DAMAGE_NOESCAPE, dam, m_name, -1);
2122                         if (p_ptr->tim_eyeeye && get_damage > 0 && !p_ptr->is_dead)
2123                         {
2124                                 char m_name_self[80];
2125                                 /* hisself */
2126                                 monster_desc(m_name_self, m_ptr, MD_PRON_VISIBLE | MD_POSSESSIVE | MD_OBJECTIVE);
2127
2128                                 msg_format(_("攻撃が%s自身を傷つけた！", "The attack of %s has wounded %s!"), m_name, m_name_self);
2129
2130                                 project(0, 0, m_ptr->fy, m_ptr->fx, get_damage, GF_MISSILE, PROJECT_KILL, -1);
2131                                 set_tim_eyeeye(p_ptr->tim_eyeeye - 5, TRUE);
2132                         }
2133                 }
2134
2135                 if(monster_to_player && p_ptr->riding)
2136                         mon_take_hit_mon(p_ptr->riding, dam, &fear, extract_note_dies(real_r_ptr(&m_list[p_ptr->riding])), m_idx);
2137
2138                 if(monster_to_monster)
2139                         mon_take_hit_mon(t_idx, dam, &fear, extract_note_dies(real_r_ptr(t_ptr)), m_idx);
2140         }
2141         return dam;
2142 }
2143
2144 /*!
2145 * @brief RF6_SPECIALの処理。モンスターの種類によって実処理に振り分ける。 /
2146 * @param y 対象の地点のy座標
2147 * @param x 対象の地点のx座標
2148 * @param m_idx 呪文を唱えるモンスターID
2149 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2150 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2151 * @return ダメージ量を返す。
2152 */
2153 int spell_RF6_SPECIAL(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2154 {
2155     monster_type    *m_ptr = &m_list[m_idx];
2156     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
2157     u32b mode = 0L;
2158     int count=0;
2159
2160     disturb(1, 1);
2161     switch (m_ptr->r_idx)
2162     {
2163         case MON_OHMU:
2164             /* Moved to process_monster(), like multiplication */
2165             return -1;
2166
2167         case MON_BANORLUPART:
2168         case MON_BANOR:
2169         case MON_LUPART:
2170                         return spell_RF6_SPECIAL_BANORLUPART(m_idx);
2171
2172         case MON_ROLENTO:
2173                         return spell_RF6_SPECIAL_ROLENTO(y, x, m_idx, t_idx, TARGET_TYPE);
2174             break;
2175
2176         default:
2177         if (r_ptr->d_char == 'B')
2178         {
2179             return spell_RF6_SPECIAL_B(y, x, m_idx, t_idx, TARGET_TYPE);
2180             break;
2181         }
2182
2183         /* Something is wrong */
2184         else return -1;
2185     }
2186 }
2187
2188 /*!
2189 * @brief RF6_TELE_TOの処理。テレポート・バック。 /
2190 * @param m_idx 呪文を唱えるモンスターID
2191 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2192 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2193 * @return ダメージ量を返す。
2194 */
2195 void spell_RF6_TELE_TO(int m_idx, int t_idx, int TARGET_TYPE)
2196 {
2197     monster_type    *m_ptr = &m_list[m_idx];
2198     monster_type    *t_ptr = &m_list[t_idx];
2199     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
2200
2201         simple_monspell_message(m_idx, t_idx,
2202                 _("%^sがあなたを引き戻した。", "%^s commands you to return."),
2203                 _("%^sが%sを引き戻した。", "%^s commands %s to return."),
2204                 TARGET_TYPE);
2205
2206         if (TARGET_TYPE == MONSTER_TO_PLAYER)
2207         {
2208                 teleport_player_to(m_ptr->fy, m_ptr->fx, TELEPORT_PASSIVE);
2209                 learn_spell(MS_TELE_TO);
2210         }
2211         else if (TARGET_TYPE == MONSTER_TO_MONSTER)
2212         {
2213                 bool resists_tele = FALSE;
2214                 char t_name[80];
2215                 monster_name(t_idx, t_name);
2216
2217                 if (tr_ptr->flagsr & RFR_RES_TELE)
2218                 {
2219                         if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL))
2220                         {
2221                                 if (is_original_ap_and_seen(t_ptr)) tr_ptr->r_flagsr |= RFR_RES_TELE;
2222                                 if (see_monster(t_idx))
2223                                 {
2224                                         msg_format(_("%^sには効果がなかった。", "%^s is unaffected!"), t_name);
2225                                 }
2226                                 resists_tele = TRUE;
2227                         }
2228                         else if (tr_ptr->level > randint1(100))
2229                         {
2230                                 if (is_original_ap_and_seen(t_ptr)) tr_ptr->r_flagsr |= RFR_RES_TELE;
2231                                 if (see_monster(t_idx))
2232                                 {
2233                                         msg_format(_("%^sは耐性を持っている！", "%^s resists!"), t_name);
2234                                 }
2235                                 resists_tele = TRUE;
2236                         }
2237                 }
2238
2239                 if (!resists_tele)
2240                 {
2241                         if (t_idx == p_ptr->riding)
2242                                 teleport_player_to(m_ptr->fy, m_ptr->fx, TELEPORT_PASSIVE);
2243                         else
2244                                 teleport_monster_to(t_idx, m_ptr->fy, m_ptr->fx, 100, TELEPORT_PASSIVE);
2245                 }
2246         monster_wakeup(t_idx);
2247         }
2248 }
2249
2250 /*!
2251 * @brief RF6_TELE_AWAYの処理。テレポート・アウェイ。 /
2252 * @param m_idx 呪文を唱えるモンスターID
2253 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2254 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2255 * @return ダメージ量を返す。
2256 */
2257 void spell_RF6_TELE_AWAY(int m_idx, int t_idx, int TARGET_TYPE)
2258 {
2259     monster_type    *m_ptr = &m_list[m_idx];
2260     monster_type    *t_ptr = &m_list[t_idx];
2261     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
2262
2263         simple_monspell_message(m_idx, t_idx,
2264                 _("%^sにテレポートさせられた。", "%^s teleports you away."),
2265                 _("%^sは%sをテレポートさせた。", "%^s teleports %s away."),
2266                 TARGET_TYPE);
2267
2268         if (TARGET_TYPE == MONSTER_TO_PLAYER)
2269         {
2270                 if ((p_ptr->pseikaku == SEIKAKU_COMBAT) || (inventory[INVEN_BOW].name1 == ART_CRIMSON))
2271                         msg_print(_("くっそ～", ""));
2272
2273                 learn_spell(MS_TELE_AWAY);
2274                 teleport_player_away(m_idx, 100);
2275         }
2276         else if (TARGET_TYPE == MONSTER_TO_MONSTER)
2277         {
2278                 bool resists_tele = FALSE;
2279                 char t_name[80];
2280                 monster_name(t_idx, t_name);
2281
2282                 if (tr_ptr->flagsr & RFR_RES_TELE)
2283                 {
2284                         if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL))
2285                         {
2286                                 if (is_original_ap_and_seen(t_ptr)) tr_ptr->r_flagsr |= RFR_RES_TELE;
2287                                 if (see_monster(t_idx))
2288                                 {
2289                                         msg_format(_("%^sには効果がなかった。", "%^s is unaffected!"), t_name);
2290                                 }
2291                                 resists_tele = TRUE;
2292                         }
2293                         else if (tr_ptr->level > randint1(100))
2294                         {
2295                                 if (is_original_ap_and_seen(t_ptr)) tr_ptr->r_flagsr |= RFR_RES_TELE;
2296                                 if (see_monster(t_idx))
2297                                 {
2298                                         msg_format(_("%^sは耐性を持っている！", "%^s resists!"), t_name);
2299                                 }
2300                                 resists_tele = TRUE;
2301                         }
2302                 }
2303
2304                 if (!resists_tele)
2305                 {
2306                         if (t_idx == p_ptr->riding)
2307                                 teleport_player_away(m_idx, MAX_SIGHT * 2 + 5);
2308                         else
2309                                 teleport_away(t_idx, MAX_SIGHT * 2 + 5, TELEPORT_PASSIVE);
2310                 }
2311         monster_wakeup(t_idx);
2312         }
2313 }
2314
2315 /*!
2316 * @brief RF6_TELE_LEVELの処理。テレポート・レベル。 /
2317 * @param m_idx 呪文を唱えるモンスターID
2318 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2319 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2320 * @return ダメージ量を返す。
2321 */
2322 void spell_RF6_TELE_LEVEL(int m_idx, int t_idx, int TARGET_TYPE)
2323 {
2324     monster_type    *t_ptr = &m_list[t_idx];
2325     monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
2326     int rlev = monster_level_idx(m_idx);
2327     bool resist, saving_throw;
2328
2329     if (TARGET_TYPE == MONSTER_TO_PLAYER)
2330     {
2331         resist = p_ptr->resist_nexus;
2332         saving_throw = (randint0(100 + rlev / 2) < p_ptr->skill_sav);
2333         spell_badstatus_message(m_idx, t_idx,
2334             _("%^sが何か奇妙な言葉をつぶやいた。", "%^s mumbles strangely."),
2335             _("%^sがあなたの足を指さした。", "%^s gestures at your feet."),
2336             _("しかし効果がなかった！", "You are unaffected!"),
2337             _("しかし効力を跳ね返した！", "You resist the effects!"),
2338             resist, saving_throw, TARGET_TYPE);
2339
2340         if (!resist && !saving_throw)
2341         {
2342                         teleport_level(0);
2343         }
2344                 learn_spell(MS_TELE_LEVEL);
2345                 update_smart_learn(m_idx, DRS_NEXUS);
2346     }
2347     else if (TARGET_TYPE == MONSTER_TO_MONSTER)
2348     {
2349         resist = tr_ptr->flagsr & (RFR_EFF_RES_NEXU_MASK | RFR_RES_TELE);
2350         saving_throw = (tr_ptr->flags1 & RF1_QUESTOR) ||
2351                                    (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
2352
2353         spell_badstatus_message(m_idx, t_idx,
2354             _("%^sが%sの足を指さした。", "%^s gestures at %s's feet."),
2355             _("%^sには効果がなかった。", "%^s is unaffected!"),
2356             _("%^sは効力を跳ね返した！", "%^s resist the effects!"),
2357             "",
2358             resist, saving_throw, TARGET_TYPE);
2359
2360         if (!resist && !saving_throw)
2361         {
2362                         teleport_level((t_idx == p_ptr->riding) ? 0 : t_idx);
2363         }
2364     }
2365 }
2366
2367 /*!
2368 * @brief RF6_PSY_SPEARの処理。光の剣。 /
2369 * @param y 対象の地点のy座標
2370 * @param x 対象の地点のx座標
2371 * @param m_idx 呪文を唱えるモンスターID
2372 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2373 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2374 * @return ダメージ量を返す。
2375 */
2376 int spell_RF6_PSY_SPEAR(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2377 {
2378     int dam;
2379
2380     monspell_message(m_idx, t_idx,
2381         _("%^sが何かをつぶやいた。", "%^s mumbles."),
2382         _("%^sが光の剣を放った。", "%^s throw a Psycho-Spear."),
2383         _("%^sが%sに向かって光の剣を放った。", "%^s throw a Psycho-spear at %s."),
2384         TARGET_TYPE);
2385
2386     dam = monspell_damage((MS_PSY_SPEAR), m_idx, DAM_ROLL);
2387     beam(m_idx, y, x, GF_PSY_SPEAR, dam, MS_PSY_SPEAR, MONSTER_TO_PLAYER);
2388     return dam;
2389 }
2390
2391 /*!
2392 * @brief RF6_DARKNESSの処理。暗闇or閃光。 /
2393 * @param y 対象の地点のy座標
2394 * @param x 対象の地点のx座標
2395 * @param m_idx 呪文を唱えるモンスターID
2396 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2397 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2398 */
2399 void spell_RF6_DARKNESS(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2400 {
2401     monster_type    *m_ptr = &m_list[m_idx];
2402     monster_type    *t_ptr = &m_list[t_idx];
2403     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
2404     bool can_use_lite_area = FALSE;
2405         bool monster_to_monster = TARGET_TYPE == MONSTER_TO_MONSTER;
2406         bool monster_to_player = TARGET_TYPE == MONSTER_TO_PLAYER;
2407         char t_name[80];
2408         monster_name(t_idx, t_name);
2409
2410     if ((p_ptr->pclass == CLASS_NINJA) &&
2411         !(r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) &&
2412         !(r_ptr->flags7 & RF7_DARK_MASK))
2413         can_use_lite_area = TRUE;
2414
2415         if(monster_to_monster && !is_hostile(t_ptr))
2416         can_use_lite_area = FALSE;
2417
2418
2419         if (can_use_lite_area)
2420         {
2421                 monspell_message(m_idx, t_idx,
2422                         _("%^sが何かをつぶやいた。", "%^s mumbles."),
2423                         _("%^sが辺りを明るく照らした。", "%^s cast a spell to light up."),
2424                         _("%^sが辺りを明るく照らした。", "%^s cast a spell to light up."),
2425                         TARGET_TYPE);
2426
2427                 if (see_monster(t_idx) && monster_to_monster)
2428                 {
2429                         msg_format(_("%^sは白い光に包まれた。", "%^s is surrounded by a white light."), t_name);
2430                 }
2431         }
2432         else
2433         {
2434                 monspell_message(m_idx, t_idx,
2435                         _("%^sが何かをつぶやいた。", "%^s mumbles."),
2436                         _("%^sが暗闇の中で手を振った。", "%^s gestures in shadow."),
2437                         _("%^sが暗闇の中で手を振った。", "%^s gestures in shadow."),
2438                         TARGET_TYPE);
2439
2440                 if (see_monster(t_idx) && monster_to_monster)
2441                 {
2442                         msg_format(_("%^sは暗闇に包まれた。", "%^s is surrounded by darkness."), t_name);
2443                 }
2444         }
2445
2446         if(monster_to_player)
2447         {
2448                 if (can_use_lite_area)
2449                 {
2450                         (void)lite_area(0, 3);
2451                 }
2452                 else
2453                 {
2454                         learn_spell(MS_DARKNESS);
2455                         (void)unlite_area(0, 3);
2456                 }
2457         }
2458         else if(monster_to_monster)
2459         {
2460                 if (can_use_lite_area)
2461                 {
2462                         (void)project(m_idx, 3, y, x, 0, GF_LITE_WEAK, PROJECT_GRID | PROJECT_KILL, -1);
2463                         lite_room(y, x);
2464                 }
2465                 else
2466                 {
2467                         (void)project(m_idx, 3, y, x, 0, GF_DARK_WEAK, PROJECT_GRID | PROJECT_KILL, MS_DARKNESS);
2468                         unlite_room(y, x);
2469                 }
2470         }
2471 }
2472
2473 /*!
2474 * @brief RF6_TRAPSの処理。トラップ。 /
2475 * @param y 対象の地点のy座標
2476 * @param x 対象の地点のx座標
2477 * @param m_idx 呪文を唱えるモンスターID
2478 */
2479 void spell_RF6_TRAPS(int y, int x, int m_idx)
2480 {
2481         char m_name[80];
2482     monster_name(m_idx, m_name);
2483     disturb(1, 1);
2484
2485     if (p_ptr->blind)
2486         msg_format(_("%^sが何かをつぶやいて邪悪に微笑んだ。",
2487         "%^s mumbles, and then cackles evilly."), m_name);
2488     else
2489         msg_format(_("%^sが呪文を唱えて邪悪に微笑んだ。",
2490         "%^s casts a spell and cackles evilly."), m_name);
2491
2492     learn_spell(MS_MAKE_TRAP);
2493     (void)trap_creation(y, x);
2494 }
2495
2496 /*!
2497 * @brief RF6_FORGETの処理。記憶消去。 /
2498 * @param m_idx 呪文を唱えるモンスターID
2499 */
2500 void spell_RF6_FORGET(int m_idx)
2501 {
2502     int rlev = monster_level_idx(m_idx);
2503         char m_name[80];
2504     monster_name(m_idx, m_name);
2505
2506     disturb(1, 1);
2507
2508     msg_format(_("%^sがあなたの記憶を消去しようとしている。",
2509         "%^s tries to blank your mind."), m_name);
2510
2511     if (randint0(100 + rlev / 2) < p_ptr->skill_sav)
2512     {
2513         msg_print(_("しかし効力を跳ね返した！", "You resist the effects!"));
2514     }
2515     else if (lose_all_info())
2516     {
2517         msg_print(_("記憶が薄れてしまった。", "Your memories fade away."));
2518     }
2519     learn_spell(MS_FORGET);
2520 }
2521
2522
2523 /*!
2524 * @brief RF6_RAISE_DEADの処理。死者復活。 /
2525 * @param m_idx 呪文を唱えるモンスターID
2526 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2527 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2528 */
2529 void spell_RF6_RAISE_DEAD(int m_idx, int t_idx, int TARGET_TYPE)
2530 {
2531     monster_type    *m_ptr = &m_list[m_idx];
2532
2533     monspell_message(m_idx, t_idx,
2534         _("%^sが何かをつぶやいた。", "%^s mumbles."),
2535         _("%^sが死者復活の呪文を唱えた。", "%^s casts a spell to revive corpses."),
2536         _("%^sが死者復活の呪文を唱えた。", "%^s casts a spell to revive corpses."),
2537         TARGET_TYPE);
2538
2539     animate_dead(m_idx, m_ptr->fy, m_ptr->fx);
2540 }
2541
2542
2543 /*!
2544 * @brief 鷹召喚の処理。 /
2545 * @param y 対象の地点のy座標
2546 * @param x 対象の地点のx座標
2547 * @param rlev 呪文を唱えるモンスターのレベル
2548 * @param m_idx 呪文を唱えるモンスターID
2549 * @return 召喚したモンスターの数を返す。
2550 */
2551 int summon_EAGLE(int y, int x, int rlev, int m_idx)
2552 {
2553         int k, count = 0;
2554         int num = 4 + randint1(3);
2555         for (k = 0; k < num; k++)
2556         {
2557                 count += summon_specific(m_idx, y, x, rlev, SUMMON_EAGLES, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
2558         }
2559         return count;
2560 }
2561
2562 /*!
2563  * @brief インターネット・エクスプローダー召喚の処理。 /
2564  * @param y 対象の地点のy座標
2565  * @param x 対象の地点のx座標
2566  * @param rlev 呪文を唱えるモンスターのレベル
2567  * @param m_idx 呪文を唱えるモンスターID
2568  * @return 召喚したモンスターの数を返す。
2569  */
2570 int summon_IE(int y, int x, int rlev, int m_idx)
2571 {
2572     u32b mode = 0L;
2573         int k, count = 0;
2574         int num = 2 + randint1(3);
2575     for (k = 0; k < num; k++)
2576     {
2577         count += summon_named_creature(m_idx, y, x, MON_IE, mode);
2578     }
2579         return count;
2580 }
2581
2582 /*!
2583  * @brief ダンジョン・ガーディアン召喚の処理。 /
2584  * @param y 対象の地点のy座標
2585  * @param x 対象の地点のx座標
2586  * @param rlev 呪文を唱えるモンスターのレベル
2587  * @param m_idx 呪文を唱えるモンスターID
2588  * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2589  * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2590  * @return 召喚したモンスターの数を返す。
2591  */
2592 int summon_Guardian(int y, int x, int rlev, int m_idx, int t_idx, int TARGET_TYPE)
2593 {
2594         int k, count = 0;
2595         int num = 2 + randint1(3);
2596     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2597     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2598
2599     if (r_info[MON_JORMUNGAND].cur_num < r_info[MON_JORMUNGAND].max_num && one_in_(6))
2600     {
2601                 simple_monspell_message(m_idx, t_idx,
2602                         _("地面から水が吹き出した！", "Water blew off from the ground!"),
2603                         _("地面から水が吹き出した！", "Water blew off from the ground!"),
2604                         TARGET_TYPE);
2605
2606                 if(mon_to_player)
2607                 fire_ball_hide(GF_WATER_FLOW, 0, 3, 8);
2608                 else if(mon_to_mon)
2609                         project(t_idx, 8, y, x, 3, GF_WATER_FLOW, PROJECT_GRID | PROJECT_HIDE, -1);
2610     }
2611
2612     for (k = 0; k < num; k++)
2613     {
2614         count += summon_specific(m_idx, y, x, rlev, SUMMON_GUARDIANS, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
2615     }
2616         return count;
2617 }
2618
2619 /*!
2620 * @brief ロックのクローン召喚の処理。 /
2621 * @param y 対象の地点のy座標
2622 * @param x 対象の地点のx座標
2623 * @param rlev 呪文を唱えるモンスターのレベル
2624 * @param m_idx 呪文を唱えるモンスターID
2625 * @return 召喚したモンスターの数を返す。
2626 */
2627 int summon_LOCK_CLONE(int y, int x, int rlev, int m_idx)
2628 {
2629     u32b mode = 0L;
2630         int k, count = 0;
2631         int num = randint1(3);
2632     for (k = 0; k < num; k++)
2633     {
2634         count += summon_named_creature(m_idx, y, x, MON_LOCKE_CLONE, mode);
2635     }
2636         return count;
2637 }
2638
2639 /*!
2640 * @brief シラミ召喚の処理。 /
2641 * @param y 対象の地点のy座標
2642 * @param x 対象の地点のx座標
2643 * @param rlev 呪文を唱えるモンスターのレベル
2644 * @param m_idx 呪文を唱えるモンスターID
2645 * @return 召喚したモンスターの数を返す。
2646 */
2647 int summon_LOUSE(int y, int x, int rlev, int m_idx)
2648 {
2649         int k, count = 0;
2650         int num = 2 + randint1(3);
2651     for (k = 0; k < num; k++)
2652     {
2653         count += summon_specific(m_idx, y, x, rlev, SUMMON_LOUSE, PM_ALLOW_GROUP);
2654     }
2655         return count;
2656 }
2657
2658 /*!
2659 * @brief 救援召喚の通常処理。同シンボルのモンスターを召喚する。 /
2660 * @param y 対象の地点のy座標
2661 * @param x 対象の地点のx座標
2662 * @param rlev 呪文を唱えるモンスターのレベル
2663 * @param m_idx 呪文を唱えるモンスターID
2664 * @return 召喚したモンスターの数を返す。
2665 */
2666 int summon_Kin(int y, int x, int rlev, int m_idx)
2667 {
2668         int k, count = 0;
2669     monster_type    *m_ptr = &m_list[m_idx];
2670     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
2671         summon_kin_type = r_ptr->d_char; /* Big hack */
2672
2673         for (k = 0; k < 4; k++)
2674         {
2675                 count += summon_specific(m_idx, y, x, rlev, SUMMON_KIN, PM_ALLOW_GROUP);
2676         }
2677         return count;
2678 }
2679
2680 /*!
2681 * @brief RF6_S_KINの処理。救援召喚。使用するモンスターの種類により、実処理に分岐させる。 /
2682 * @param y 対象の地点のy座標
2683 * @param x 対象の地点のx座標
2684 * @param m_idx 呪文を唱えるモンスターID
2685 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2686 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2687 * @return 召喚したモンスターの数を返す。
2688 */
2689 void spell_RF6_S_KIN(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2690 {
2691         bool known = monster_near_player(m_idx, t_idx);
2692     bool see_either = see_monster(m_idx) || see_monster(t_idx);
2693     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2694     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2695     monster_type    *m_ptr = &m_list[m_idx];
2696     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
2697     int rlev = monster_level_idx(m_idx);
2698     int count = 0;
2699     u32b mode = 0L;
2700         char m_name[80], t_name[80], m_poss[80];
2701     monster_name(m_idx, m_name);
2702         monster_name(t_idx, t_name);
2703         monster_desc(m_poss, m_ptr, MD_PRON_VISIBLE | MD_POSSESSIVE);
2704
2705     disturb(1, 1);
2706     if (m_ptr->r_idx == MON_SERPENT || m_ptr->r_idx == MON_ZOMBI_SERPENT)
2707     {
2708                 monspell_message(m_idx, t_idx,
2709                         _("%^sが何かをつぶやいた。", "%^s mumbles."),
2710                         _("%^sがダンジョンの主を召喚した。", "%^s magically summons guardians of dungeons."),
2711                         _("%^sがダンジョンの主を召喚した。", "%^s magically summons guardians of dungeons."),
2712                         TARGET_TYPE);
2713     }
2714     else
2715     {
2716                 if (mon_to_player || (mon_to_mon && known && see_either))
2717                         disturb(1, 1);
2718
2719                 if (p_ptr->blind)
2720                 {
2721                         if (mon_to_player)
2722                                 msg_format(_("%^sが何かをつぶやいた。", "%^s mumbles."), m_name);
2723                 }
2724                 else
2725                 {
2726                         if (mon_to_player || (mon_to_mon && known && see_either))
2727                         {
2728                                 _(msg_format("%sが魔法で%sを召喚した。", m_name, ((r_ptr->flags1 & RF1_UNIQUE) ? "手下" : "仲間")),
2729                                   msg_format("%^s magically summons %s %s.", m_name, m_poss, ((r_ptr->flags1 & RF1_UNIQUE) ? "minions" : "kin")));
2730                         }
2731                 }
2732
2733                 if (mon_to_mon && known && !see_either)
2734                         mon_fight = TRUE;
2735     }
2736
2737     switch (m_ptr->r_idx)
2738     {
2739         case MON_MENELDOR:
2740         case MON_GWAIHIR:
2741         case MON_THORONDOR:
2742                         count += summon_EAGLE(y, x, rlev, m_idx);
2743                         break;
2744
2745         case MON_BULLGATES:
2746                         count += summon_IE(y, x, rlev, m_idx);
2747                 break;
2748
2749         case MON_SERPENT:
2750         case MON_ZOMBI_SERPENT:
2751                         count += summon_Guardian(y, x, rlev, m_idx, t_idx, TARGET_TYPE);
2752                 break;
2753
2754         case MON_CALDARM:
2755                         count += summon_LOCK_CLONE(y, x, rlev, m_idx);
2756                         break;
2757
2758         case MON_LOUSY:
2759                         count += summon_LOUSE(y, x, rlev, m_idx);
2760                 break;
2761
2762         default:
2763                         count += summon_Kin(y, x, rlev, m_idx);
2764                         break;
2765     }
2766
2767     if (p_ptr->blind && count && mon_to_player)
2768         msg_print(_("多くのものが間近に現れた音がする。", "You hear many things appear nearby."));
2769
2770         if (known && !see_monster(t_idx) && count && mon_to_mon)
2771                 mon_fight = TRUE;
2772 }
2773
2774 /*!
2775 * @brief RF6_S_CYBERの処理。サイバー・デーモン召喚。 /
2776 * @param y 対象の地点のy座標
2777 * @param x 対象の地点のx座標
2778 * @param m_idx 呪文を唱えるモンスターID
2779 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2780 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2781 * @return 召喚したモンスターの数を返す。
2782 */
2783 void spell_RF6_S_CYBER(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2784 {
2785     int count = 0;
2786     monster_type    *m_ptr = &m_list[m_idx];
2787     int rlev = monster_level_idx(m_idx);
2788     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2789     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2790
2791         monspell_message(m_idx, t_idx,
2792                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
2793                 _("%^sがサイバーデーモンを召喚した！", "%^s magically summons Cyberdemons!"),
2794                 _("%^sがサイバーデーモンを召喚した！", "%^s magically summons Cyberdemons!"),
2795                 TARGET_TYPE);
2796
2797         if (is_friendly(m_ptr) && mon_to_mon)
2798         {
2799                 count += summon_specific(m_idx, y, x, rlev, SUMMON_CYBER, (PM_ALLOW_GROUP));
2800         }
2801         else
2802         {
2803                 count += summon_cyber(m_idx, y, x);
2804         }
2805
2806     if (p_ptr->blind && count && mon_to_player)
2807         msg_print(_("重厚な足音が近くで聞こえる。", "You hear heavy steps nearby."));
2808
2809         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
2810                 mon_fight = TRUE;
2811 }
2812
2813 /*!
2814 * @brief RF6_S_MONSTERの処理。モンスター一体召喚。 /
2815 * @param y 対象の地点のy座標
2816 * @param x 対象の地点のx座標
2817 * @param m_idx 呪文を唱えるモンスターID
2818 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2819 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2820 * @return 召喚したモンスターの数を返す。
2821 */
2822 void spell_RF6_S_MONSTER(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2823 {
2824     int count = 0, k;
2825     monster_type    *m_ptr = &m_list[m_idx];
2826     int rlev = monster_level_idx(m_idx);
2827     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2828     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2829
2830         monspell_message(m_idx, t_idx,
2831                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
2832                 _("%^sが魔法で仲間を召喚した！", "%^s magically summons help!"),
2833                 _("%^sが魔法で仲間を召喚した！", "%^s magically summons help!"),
2834                 TARGET_TYPE);
2835
2836     for (k = 0; k < 1; k++)
2837     {
2838                 if(mon_to_player)
2839                 count += summon_specific(m_idx, y, x, rlev, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
2840
2841                 if(mon_to_mon)
2842                         count += summon_specific(m_idx, y, x, rlev, 0, (monster_u_mode(m_idx)));
2843     }
2844
2845     if (p_ptr->blind && count && mon_to_player)
2846         msg_print(_("何かが間近に現れた音がする。", "You hear something appear nearby."));
2847
2848         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
2849                 mon_fight = TRUE;
2850 }
2851
2852 /*!
2853 * @brief RF6_S_MONSTERSの処理。モンスター複数召喚。 /
2854 * @param y 対象の地点のy座標
2855 * @param x 対象の地点のx座標
2856 * @param m_idx 呪文を唱えるモンスターID
2857 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2858 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2859 * @return 召喚したモンスターの数を返す。
2860 */
2861 void spell_RF6_S_MONSTERS(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2862 {
2863     int count = 0, k;
2864     monster_type    *m_ptr = &m_list[m_idx];
2865     int rlev = monster_level_idx(m_idx);
2866     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2867     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2868
2869         monspell_message(m_idx, t_idx,
2870                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
2871                 _("%^sが魔法でモンスターを召喚した！", "%^s magically summons monsters!"),
2872                 _("%^sが魔法でモンスターを召喚した！", "%^s magically summons monsters!"),
2873                 TARGET_TYPE);
2874
2875     for (k = 0; k < S_NUM_6; k++)
2876     {
2877                 if(mon_to_player)
2878                         count += summon_specific(m_idx, y, x, rlev, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
2879
2880                 if(mon_to_mon)
2881                         count += summon_specific(m_idx, y, x, rlev, 0, (PM_ALLOW_GROUP | monster_u_mode(m_idx)));
2882     }
2883
2884     if (p_ptr->blind && count && mon_to_player)
2885         msg_print(_("多くのものが間近に現れた音がする。", "You hear many things appear nearby."));
2886
2887         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
2888                 mon_fight = TRUE;
2889 }
2890
2891 /*!
2892 * @brief RF6_S_ANTの処理。アリ召喚。 /
2893 * @param y 対象の地点のy座標
2894 * @param x 対象の地点のx座標
2895 * @param m_idx 呪文を唱えるモンスターID
2896 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2897 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2898 * @return 召喚したモンスターの数を返す。
2899 */
2900 void spell_RF6_S_ANT(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2901 {
2902     int count = 0, k;
2903     monster_type    *m_ptr = &m_list[m_idx];
2904     int rlev = monster_level_idx(m_idx);
2905     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2906     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2907
2908         monspell_message(m_idx, t_idx,
2909                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
2910                 _("%^sが魔法でアリを召喚した。", "%^s magically summons ants."),
2911                 _("%^sが魔法でアリを召喚した。", "%^s magically summons ants."),
2912                 TARGET_TYPE);
2913
2914     for (k = 0; k < S_NUM_6; k++)
2915     {
2916         count += summon_specific(m_idx, y, x, rlev, SUMMON_ANT, PM_ALLOW_GROUP);
2917     }
2918
2919     if (p_ptr->blind && count && mon_to_player)
2920         msg_print(_("多くのものが間近に現れた音がする。", "You hear many things appear nearby."));
2921
2922         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
2923                 mon_fight = TRUE;
2924 }
2925
2926 /*!
2927 * @brief RF6_S_SPIDERの処理。クモ召喚。 /
2928 * @param y 対象の地点のy座標
2929 * @param x 対象の地点のx座標
2930 * @param m_idx 呪文を唱えるモンスターID
2931 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2932 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2933 * @return 召喚したモンスターの数を返す。
2934 */
2935 void spell_RF6_S_SPIDER(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2936 {
2937     int count = 0, k;
2938     monster_type    *m_ptr = &m_list[m_idx];
2939     int rlev = monster_level_idx(m_idx);
2940     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2941     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2942
2943         monspell_message(m_idx, t_idx,
2944                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
2945                 _("%^sが魔法でクモを召喚した。", "%^s magically summons spiders."),
2946                 _("%^sが魔法でクモを召喚した。", "%^s magically summons spiders."),
2947                 TARGET_TYPE);
2948
2949     for (k = 0; k < S_NUM_6; k++)
2950     {
2951         count += summon_specific(m_idx, y, x, rlev, SUMMON_SPIDER, PM_ALLOW_GROUP);
2952     }
2953
2954     if (p_ptr->blind && count && mon_to_player)
2955         msg_print(_("多くのものが間近に現れた音がする。", "You hear many things appear nearby."));
2956
2957         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
2958                 mon_fight = TRUE;
2959 }
2960
2961 /*!
2962 * @brief RF6_S_HOUNDの処理。ハウンド召喚。 /
2963 * @param y 対象の地点のy座標
2964 * @param x 対象の地点のx座標
2965 * @param m_idx 呪文を唱えるモンスターID
2966 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
2967 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
2968 * @return 召喚したモンスターの数を返す。
2969 */
2970 void spell_RF6_S_HOUND(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
2971 {
2972     int count = 0, k;
2973     monster_type    *m_ptr = &m_list[m_idx];
2974     int rlev = monster_level_idx(m_idx);
2975     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
2976     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
2977
2978         monspell_message(m_idx, t_idx,
2979                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
2980                 _("%^sが魔法でハウンドを召喚した。", "%^s magically summons hounds."),
2981                 _("%^sが魔法でハウンドを召喚した。", "%^s magically summons hounds."),
2982                 TARGET_TYPE);
2983
2984         for (k = 0; k < S_NUM_4; k++)
2985     {
2986         count += summon_specific(m_idx, y, x, rlev, SUMMON_HOUND, PM_ALLOW_GROUP);
2987     }
2988
2989     if (p_ptr->blind && count && mon_to_player)
2990         msg_print(_("多くのものが間近に現れた音がする。", "You hear many things appear nearby."));
2991
2992         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
2993                 mon_fight = TRUE;
2994 }
2995
2996 /*!
2997 * @brief RF6_S_HYDRAの処理。ヒドラ召喚。 /
2998 * @param y 対象の地点のy座標
2999 * @param x 対象の地点のx座標
3000 * @param m_idx 呪文を唱えるモンスターID
3001 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3002 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3003 * @return 召喚したモンスターの数を返す。
3004 */
3005 void spell_RF6_S_HYDRA(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3006 {
3007     int count = 0, k;
3008     monster_type    *m_ptr = &m_list[m_idx];
3009     int rlev = monster_level_idx(m_idx);
3010     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3011     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3012
3013         monspell_message(m_idx, t_idx,
3014                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3015                 _("%^sが魔法でヒドラを召喚した。", "%^s magically summons hydras."),
3016                 _("%^sが魔法でヒドラを召喚した。", "%^s magically summons hydras."),
3017                 TARGET_TYPE);
3018
3019         for (k = 0; k < S_NUM_4; k++)
3020     {
3021         count += summon_specific(m_idx, y, x, rlev, SUMMON_HYDRA, PM_ALLOW_GROUP);
3022     }
3023
3024     if (p_ptr->blind && count && mon_to_player)
3025         msg_print(_("多くのものが間近に現れた音がする。", "You hear many things appear nearby."));
3026
3027         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3028                 mon_fight = TRUE;
3029 }
3030
3031 /*!
3032 * @brief RF6_S_ANGELの処理。天使一体召喚。 /
3033 * @param y 対象の地点のy座標
3034 * @param x 対象の地点のx座標
3035 * @param m_idx 呪文を唱えるモンスターID
3036 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3037 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3038 * @return 召喚したモンスターの数を返す。
3039 */
3040 void spell_RF6_S_ANGEL(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3041 {
3042     int count = 0, k;
3043     int num = 1;
3044     monster_type    *m_ptr = &m_list[m_idx];
3045     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
3046     int rlev = monster_level_idx(m_idx);
3047     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3048     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3049
3050         monspell_message(m_idx, t_idx,
3051                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3052                 _("%^sが魔法で天使を召喚した！", "%^s magically summons an angel!"),
3053                 _("%^sが魔法で天使を召喚した！", "%^s magically summons an angel!"),
3054                 TARGET_TYPE);
3055
3056     if ((r_ptr->flags1 & RF1_UNIQUE) && !easy_band)
3057     {
3058         num += r_ptr->level / 40;
3059     }
3060
3061         for (k = 0; k < num; k++)
3062         {
3063         count += summon_specific(m_idx, y, x, rlev, SUMMON_ANGEL, PM_ALLOW_GROUP);
3064         }
3065
3066     if (count < 2)
3067     {
3068         if (p_ptr->blind && count)
3069             msg_print(_("何かが間近に現れた音がする。", "You hear something appear nearby."));
3070     }
3071     else
3072     {
3073         if (p_ptr->blind)
3074             msg_print(_("多くのものが間近に現れた音がする。", "You hear many things appear nearby."));
3075     }
3076
3077         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3078                 mon_fight = TRUE;
3079 }
3080
3081 /*!
3082 * @brief RF6_S_DEMONの処理。デーモン一体召喚。 /
3083 * @param y 対象の地点のy座標
3084 * @param x 対象の地点のx座標
3085 * @param m_idx 呪文を唱えるモンスターID
3086 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3087 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3088 * @return 召喚したモンスターの数を返す。
3089 */
3090 void spell_RF6_S_DEMON(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3091 {
3092     int count = 0, k;
3093     monster_type    *m_ptr = &m_list[m_idx];
3094     int rlev = monster_level_idx(m_idx);
3095     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3096     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3097
3098         monspell_message(m_idx, t_idx,
3099                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3100                 _("%^sは魔法で混沌の宮廷から悪魔を召喚した！", "%^s magically summons a demon from the Courts of Chaos!"),
3101                 _("%^sは魔法で混沌の宮廷から悪魔を召喚した！", "%^s magically summons a demon from the Courts of Chaos!"),
3102                 TARGET_TYPE);
3103
3104         for (k = 0; k < 1; k++)
3105         {
3106         count += summon_specific(m_idx, y, x, rlev, SUMMON_DEMON, PM_ALLOW_GROUP);
3107         }
3108
3109     if (p_ptr->blind && count)
3110         msg_print(_("何かが間近に現れた音がする。", "You hear something appear nearby."));
3111
3112         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3113                 mon_fight = TRUE;
3114 }
3115
3116 /*!
3117 * @brief RF6_S_UNDEADの処理。アンデッド一体召喚。 /
3118 * @param y 対象の地点のy座標
3119 * @param x 対象の地点のx座標
3120 * @param m_idx 呪文を唱えるモンスターID
3121 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3122 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3123 * @return 召喚したモンスターの数を返す。
3124 */
3125 void spell_RF6_S_UNDEAD(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3126 {
3127     int count = 0, k;
3128     monster_type    *m_ptr = &m_list[m_idx];
3129     int rlev = monster_level_idx(m_idx);
3130     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3131     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3132
3133         monspell_message(m_idx, t_idx,
3134                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3135                 _("%^sが魔法でアンデッドの強敵を召喚した！", "%^s magically summons an undead adversary!"),
3136                 _("%sが魔法でアンデッドを召喚した。", "%^s magically summons undead."),
3137                 TARGET_TYPE);
3138
3139         for (k = 0; k < 1; k++)
3140         {
3141         count += summon_specific(m_idx, y, x, rlev, SUMMON_UNDEAD, PM_ALLOW_GROUP);
3142         }
3143
3144     if (p_ptr->blind && count)
3145         msg_print(_("何かが間近に現れた音がする。", "You hear something appear nearby."));
3146
3147         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3148                 mon_fight = TRUE;
3149 }
3150
3151 /*!
3152 * @brief RF6_S_DRAGONの処理。ドラゴン一体召喚。 /
3153 * @param y 対象の地点のy座標
3154 * @param x 対象の地点のx座標
3155 * @param m_idx 呪文を唱えるモンスターID
3156 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3157 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3158 * @return 召喚したモンスターの数を返す。
3159 */
3160 void spell_RF6_S_DRAGON(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3161 {
3162     int count = 0, k;
3163     monster_type    *m_ptr = &m_list[m_idx];
3164     int rlev = monster_level_idx(m_idx);
3165     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3166     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3167
3168         monspell_message(m_idx, t_idx,
3169                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3170                 _("%^sが魔法でドラゴンを召喚した！", "%^s magically summons a dragon!"),
3171                 _("%^sが魔法でドラゴンを召喚した！", "%^s magically summons a dragon!"),
3172                 TARGET_TYPE);
3173
3174         for (k = 0; k < 1; k++)
3175         {
3176         count += summon_specific(m_idx, y, x, rlev, SUMMON_DRAGON, PM_ALLOW_GROUP);
3177         }
3178
3179     if (p_ptr->blind && count)
3180         msg_print(_("何かが間近に現れた音がする。", "You hear something appear nearby."));
3181
3182         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3183                 mon_fight = TRUE;
3184 }
3185
3186 /*!
3187 * @brief ナズグル戦隊召喚の処理。 /
3188 * @param y 対象の地点のy座標
3189 * @param x 対象の地点のx座標
3190 * @param m_idx 呪文を唱えるモンスターID
3191 * @return 召喚したモンスターの数を返す。
3192 */
3193 int summon_NAZGUL(int y, int x, int m_idx)
3194 {
3195     u32b mode = 0L;
3196         int count = 0, k;
3197         int cy = y;
3198     int cx = x;
3199         char m_name[80];
3200     monster_name(m_idx, m_name);
3201
3202     if (p_ptr->blind)
3203         msg_format(_("%^sが何かをつぶやいた。", "%^s mumbles."), m_name);
3204     else
3205         msg_format(_("%^sが魔法で幽鬼戦隊を召喚した！", "%^s magically summons rangers of Nazgul!"), m_name);
3206
3207     msg_print(NULL);
3208
3209     for (k = 0; k < 30; k++)
3210     {
3211         if (!summon_possible(cy, cx) || !cave_empty_bold(cy, cx))
3212         {
3213             int j;
3214             for (j = 100; j > 0; j--)
3215             {
3216                 scatter(&cy, &cx, y, x, 2, 0);
3217                 if (cave_empty_bold(cy, cx)) break;
3218             }
3219             if (!j) break;
3220         }
3221         if (!cave_empty_bold(cy, cx)) continue;
3222
3223         if (summon_named_creature(m_idx, cy, cx, MON_NAZGUL, mode))
3224         {
3225             y = cy;
3226             x = cx;
3227             count++;
3228             if (count == 1)
3229                 msg_format(_("「幽鬼戦隊%d号、ナズグル・ブラック！」",
3230                 "A Nazgul says 'Nazgul-Rangers Number %d, Nazgul-Black!'"), count);
3231             else
3232                 msg_format(_("「同じく%d号、ナズグル・ブラック！」",
3233                 "Another one says 'Number %d, Nazgul-Black!'"), count);
3234
3235             msg_print(NULL);
3236         }
3237     }
3238     msg_format(_("「%d人そろって、リングレンジャー！」",
3239         "They say 'The %d meets! We are the Ring-Ranger!'."), count);
3240     msg_print(NULL);
3241         return count;
3242 }
3243
3244 /*!
3245 * @brief RF6_S_HI_UNDEADの処理。強力なアンデッド召喚。 /
3246 * @param y 対象の地点のy座標
3247 * @param x 対象の地点のx座標
3248 * @param m_idx 呪文を唱えるモンスターID
3249 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3250 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3251 * @return 召喚したモンスターの数を返す。
3252 */
3253 void spell_RF6_S_HI_UNDEAD(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3254 {
3255     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3256     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3257     monster_type    *m_ptr = &m_list[m_idx];
3258     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
3259     int rlev = monster_level_idx(m_idx);
3260     int k, count = 0;
3261         char m_name[80];
3262     monster_name(m_idx, m_name);
3263
3264     disturb(1, 1);
3265
3266     if (((m_ptr->r_idx == MON_MORGOTH) || (m_ptr->r_idx == MON_SAURON) || (m_ptr->r_idx == MON_ANGMAR)) &&
3267                 ((r_info[MON_NAZGUL].cur_num + 2) < r_info[MON_NAZGUL].max_num) &&
3268                 mon_to_player)
3269     {
3270         count +=  summon_NAZGUL(y, x, m_idx);
3271     }
3272     else
3273     {
3274                 monspell_message(m_idx, t_idx,
3275                         _("%^sが何かをつぶやいた。", "%^s mumbles."),
3276                         _("%^sが魔法で強力なアンデッドを召喚した！", "%^s magically summons greater undead!"),
3277                         _("%sが魔法でアンデッドを召喚した。", "%^s magically summons undead."),
3278                         TARGET_TYPE);
3279
3280         for (k = 0; k < S_NUM_6; k++)
3281         {
3282                         if(mon_to_player)
3283                     count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_UNDEAD, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
3284
3285                         if(mon_to_mon)
3286                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_UNDEAD, (PM_ALLOW_GROUP | monster_u_mode(m_idx)));
3287         }
3288     }
3289     if (p_ptr->blind && count && mon_to_player)
3290     {
3291         msg_print(_("間近で何か多くのものが這い回る音が聞こえる。", "You hear many creepy things appear nearby."));
3292     }
3293
3294         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3295                 mon_fight = TRUE;
3296 }
3297
3298 /*!
3299 * @brief RF6_S_HI_DRAGONの処理。古代ドラゴン召喚。 /
3300 * @param y 対象の地点のy座標
3301 * @param x 対象の地点のx座標
3302 * @param m_idx 呪文を唱えるモンスターID
3303 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3304 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3305 * @return 召喚したモンスターの数を返す。
3306 */
3307 void spell_RF6_S_HI_DRAGON(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3308 {
3309     int count = 0, k;
3310     monster_type    *m_ptr = &m_list[m_idx];
3311     int rlev = monster_level_idx(m_idx);
3312     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3313     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3314
3315         monspell_message(m_idx, t_idx,
3316                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3317                 _("%^sが魔法で古代ドラゴンを召喚した！", "%^s magically summons ancient dragons!"),
3318                 _("%^sが魔法で古代ドラゴンを召喚した！", "%^s magically summons ancient dragons!"),
3319                 TARGET_TYPE);
3320
3321     for (k = 0; k < S_NUM_4; k++)
3322     {
3323                 if(mon_to_player)
3324                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_DRAGON, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
3325
3326                 if(mon_to_mon)
3327                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_DRAGON, (PM_ALLOW_GROUP | monster_u_mode(m_idx)));
3328     }
3329
3330     if (p_ptr->blind && count && mon_to_player)
3331     {
3332         msg_print(_("多くの力強いものが間近に現れた音が聞こえる。", "You hear many powerful things appear nearby."));
3333     }
3334
3335         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3336                 mon_fight = TRUE;
3337 }
3338
3339 /*!
3340 * @brief RF6_S_AMBERITESの処理。アンバーの王族召喚。 /
3341 * @param y 対象の地点のy座標
3342 * @param x 対象の地点のx座標
3343 * @param m_idx 呪文を唱えるモンスターID
3344 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3345 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3346 * @return 召喚したモンスターの数を返す。
3347 */
3348 void spell_RF6_S_AMBERITES(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3349 {
3350     int count = 0, k;
3351     monster_type    *m_ptr = &m_list[m_idx];
3352     int rlev = monster_level_idx(m_idx);
3353     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3354     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3355
3356         monspell_message(m_idx, t_idx,
3357                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3358                 _("%^sがアンバーの王族を召喚した！", "%^s magically summons Lords of Amber!"),
3359                 _("%^sがアンバーの王族を召喚した！", "%^s magically summons Lords of Amber!"),
3360                 TARGET_TYPE);
3361
3362     for (k = 0; k < S_NUM_4; k++)
3363     {
3364                 count += summon_specific(m_idx, y, x, rlev, SUMMON_AMBERITES, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
3365     }
3366
3367     if (p_ptr->blind && count && mon_to_player)
3368     {
3369         msg_print(_("不死の者が近くに現れるのが聞こえた。", "You hear immortal beings appear nearby."));
3370     }
3371
3372         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3373                 mon_fight = TRUE;
3374 }
3375
3376 /*!
3377 * @brief RF6_S_UNIQUEの処理。ユニーク・モンスター召喚。 /
3378 * @param y 対象の地点のy座標
3379 * @param x 対象の地点のx座標
3380 * @param m_idx 呪文を唱えるモンスターID
3381 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3382 * @param TARGET_TYPE プレイヤーを対象とする場合MONSTER_TO_PLAYER、モンスターを対象とする場合MONSTER_TO_MONSTER
3383 * @return 召喚したモンスターの数を返す。
3384 */
3385 void spell_RF6_S_UNIQUE(int y, int x, int m_idx, int t_idx, int TARGET_TYPE)
3386 {
3387     int count = 0, k;
3388     monster_type    *m_ptr = &m_list[m_idx];
3389     int rlev = monster_level_idx(m_idx);
3390     bool mon_to_mon = (TARGET_TYPE == MONSTER_TO_MONSTER);
3391     bool mon_to_player = (TARGET_TYPE == MONSTER_TO_PLAYER);
3392     bool uniques_are_summoned = FALSE;
3393     int non_unique_type = SUMMON_HI_UNDEAD;
3394
3395         monspell_message(m_idx, t_idx,
3396                 _("%^sが何かをつぶやいた。", "%^s mumbles."),
3397                 _("%^sが魔法で特別な強敵を召喚した！", "%^s magically summons special opponents!"),
3398                 _("%^sが魔法で特別な強敵を召喚した！", "%^s magically summons special opponents!"),
3399                 TARGET_TYPE);
3400
3401     for (k = 0; k < S_NUM_4; k++)
3402     {
3403         count += summon_specific(m_idx, y, x, rlev, SUMMON_UNIQUE, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
3404     }
3405
3406     if (count) uniques_are_summoned = TRUE;
3407
3408     if ((m_ptr->sub_align & (SUB_ALIGN_GOOD | SUB_ALIGN_EVIL)) == (SUB_ALIGN_GOOD | SUB_ALIGN_EVIL))
3409         non_unique_type = 0;
3410     else if (m_ptr->sub_align & SUB_ALIGN_GOOD)
3411         non_unique_type = SUMMON_ANGEL;
3412
3413     for (k = count; k < S_NUM_4; k++)
3414     {
3415         count += summon_specific(m_idx, y, x, rlev, non_unique_type, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
3416     }
3417
3418     if (p_ptr->blind && count && mon_to_player)
3419     {
3420         msg_format(_("多くの%sが間近に現れた音が聞こえる。", "You hear many %s appear nearby."),
3421             uniques_are_summoned ? _("力強いもの", "powerful things") : _("もの", "things"));
3422     }
3423
3424         if (monster_near_player(m_idx, t_idx) && !see_monster(t_idx) && count && mon_to_mon)
3425                 mon_fight = TRUE;
3426 }
3427
3428
3429
3430 /*!
3431 * @brief モンスターからプレイヤーへの呪文の振り分け関数。 /
3432 * @param SPELL_NUM モンスター魔法ID
3433 * @param y 対象の地点のy座標
3434 * @param x 対象の地点のx座標
3435 * @param m_idx 呪文を唱えるモンスターID
3436 * @return 攻撃呪文のダメージ、または召喚したモンスターの数を返す。その他の場合0。以降の処理を中断するなら-1を返す。
3437 */
3438 int monspell_to_player(int SPELL_NUM, int y, int x, int m_idx)
3439 {
3440     switch (SPELL_NUM)
3441     {
3442     case RF4_SPELL_START + 0:   spell_RF4_SHRIEK(m_idx, 0, MONSTER_TO_PLAYER); break;    /* RF4_SHRIEK */
3443     case RF4_SPELL_START + 1:   break;   /* RF4_XXX1 */
3444     case RF4_SPELL_START + 2:   spell_RF4_DISPEL(m_idx, 0, MONSTER_TO_PLAYER); break;    /* RF4_DISPEL */
3445     case RF4_SPELL_START + 3:   return spell_RF4_ROCKET(y, x, m_idx, 0, MONSTER_TO_PLAYER);  /* RF4_ROCKET */
3446     case RF4_SPELL_START + 4:   return spell_RF4_SHOOT(y, x, m_idx, 0, MONSTER_TO_PLAYER);   /* RF4_SHOOT */
3447     case RF4_SPELL_START + 5:   break;   /* RF4_XXX2 */
3448     case RF4_SPELL_START + 6:   break;   /* RF4_XXX3 */
3449     case RF4_SPELL_START + 7:   break;   /* RF4_XXX4 */
3450     case RF4_SPELL_START + 8:   return spell_RF4_BREATH(GF_ACID, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_ACID */
3451     case RF4_SPELL_START + 9:   return spell_RF4_BREATH(GF_ELEC, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_ELEC */
3452     case RF4_SPELL_START + 10:  return spell_RF4_BREATH(GF_FIRE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_FIRE */
3453     case RF4_SPELL_START + 11:  return spell_RF4_BREATH(GF_COLD, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_COLD */
3454     case RF4_SPELL_START + 12:  return spell_RF4_BREATH(GF_POIS, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_POIS */
3455     case RF4_SPELL_START + 13:  return spell_RF4_BREATH(GF_NETHER, y, x, m_idx, 0, MONSTER_TO_PLAYER);   /* RF4_BR_NETH */
3456     case RF4_SPELL_START + 14:  return spell_RF4_BREATH(GF_LITE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_LITE */
3457     case RF4_SPELL_START + 15:  return spell_RF4_BREATH(GF_DARK, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DARK */
3458     case RF4_SPELL_START + 16:  return spell_RF4_BREATH(GF_CONFUSION, y, x, m_idx, 0, MONSTER_TO_PLAYER);    /* RF4_BR_CONF */
3459     case RF4_SPELL_START + 17:  return spell_RF4_BREATH(GF_SOUND, y, x, m_idx, 0, MONSTER_TO_PLAYER);    /* RF4_BR_SOUN */
3460     case RF4_SPELL_START + 18:  return spell_RF4_BREATH(GF_CHAOS, y, x, m_idx, 0, MONSTER_TO_PLAYER);    /* RF4_BR_CHAO */
3461     case RF4_SPELL_START + 19:  return spell_RF4_BREATH(GF_DISENCHANT, y, x, m_idx, 0, MONSTER_TO_PLAYER);   /* RF4_BR_DISE */
3462     case RF4_SPELL_START + 20:  return spell_RF4_BREATH(GF_NEXUS, y, x, m_idx, 0, MONSTER_TO_PLAYER);    /* RF4_BR_NEXU */
3463     case RF4_SPELL_START + 21:  return spell_RF4_BREATH(GF_TIME, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_TIME */
3464     case RF4_SPELL_START + 22:  return spell_RF4_BREATH(GF_INERTIA, y, x, m_idx, 0, MONSTER_TO_PLAYER);  /* RF4_BR_INER */
3465     case RF4_SPELL_START + 23:  return spell_RF4_BREATH(GF_GRAVITY, y, x, m_idx, 0, MONSTER_TO_PLAYER);  /* RF4_BR_GRAV */
3466     case RF4_SPELL_START + 24:  return spell_RF4_BREATH(GF_SHARDS, y, x, m_idx, 0, MONSTER_TO_PLAYER);   /* RF4_BR_SHAR */
3467     case RF4_SPELL_START + 25:  return spell_RF4_BREATH(GF_PLASMA, y, x, m_idx, 0, MONSTER_TO_PLAYER);   /* RF4_BR_PLAS */
3468     case RF4_SPELL_START + 26:  return spell_RF4_BREATH(GF_FORCE, y, x, m_idx, 0, MONSTER_TO_PLAYER);    /* RF4_BR_WALL */
3469     case RF4_SPELL_START + 27:  return spell_RF4_BREATH(GF_MANA, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_MANA */
3470     case RF4_SPELL_START + 28:  return spell_RF4_BA_NUKE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BA_NUKE */
3471     case RF4_SPELL_START + 29:  return spell_RF4_BREATH(GF_NUKE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_NUKE */
3472     case RF4_SPELL_START + 30:  return spell_RF4_BA_CHAO(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BA_CHAO */
3473     case RF4_SPELL_START + 31:  return spell_RF4_BREATH(GF_DISINTEGRATE, y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF4_BR_DISI */
3474     case RF5_SPELL_START + 0:  return spell_RF5_BA_ACID(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_ACID */
3475     case RF5_SPELL_START + 1:  return spell_RF5_BA_ELEC(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_ELEC */
3476     case RF5_SPELL_START + 2:  return spell_RF5_BA_FIRE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_FIRE */
3477     case RF5_SPELL_START + 3:  return spell_RF5_BA_COLD(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_COLD */
3478     case RF5_SPELL_START + 4:  return spell_RF5_BA_POIS(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_POIS */
3479     case RF5_SPELL_START + 5:  return spell_RF5_BA_NETH(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_NETH */
3480     case RF5_SPELL_START + 6:  return spell_RF5_BA_WATE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_WATE */
3481     case RF5_SPELL_START + 7:  return spell_RF5_BA_MANA(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_MANA */
3482     case RF5_SPELL_START + 8:  return spell_RF5_BA_DARK(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_DARK */
3483     case RF5_SPELL_START + 9:  return spell_RF5_DRAIN_MANA(y, x, m_idx, 0, MONSTER_TO_PLAYER);  /* RF5_DRAIN_MANA */
3484     case RF5_SPELL_START + 10: return spell_RF5_MIND_BLAST(y, x, m_idx, 0, MONSTER_TO_PLAYER);  /* RF5_MIND_BLAST */
3485     case RF5_SPELL_START + 11: return spell_RF5_BRAIN_SMASH(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_MIND_BLAST */
3486     case RF5_SPELL_START + 12: return spell_RF5_CAUSE_1(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_CAUSE_1 */
3487     case RF5_SPELL_START + 13: return spell_RF5_CAUSE_2(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_CAUSE_2 */
3488     case RF5_SPELL_START + 14: return spell_RF5_CAUSE_3(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_CAUSE_3 */
3489     case RF5_SPELL_START + 15: return spell_RF5_CAUSE_4(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_CAUSE_4 */
3490     case RF5_SPELL_START + 16: return spell_RF5_BO_ACID(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_ACID */
3491     case RF5_SPELL_START + 17: return spell_RF5_BO_ELEC(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_ELEC */
3492     case RF5_SPELL_START + 18: return spell_RF5_BO_FIRE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_FIRE */
3493     case RF5_SPELL_START + 19: return spell_RF5_BO_COLD(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_COLD */
3494     case RF5_SPELL_START + 20: return spell_RF5_BA_LITE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BA_LITE */
3495     case RF5_SPELL_START + 21: return spell_RF5_BO_NETH(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_NETH */
3496     case RF5_SPELL_START + 22: return spell_RF5_BO_WATE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_WATE */
3497     case RF5_SPELL_START + 23: return spell_RF5_BO_MANA(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_MANA */
3498     case RF5_SPELL_START + 24: return spell_RF5_BO_PLAS(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_PLAS */
3499     case RF5_SPELL_START + 25: return spell_RF5_BO_ICEE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_BO_ICEE */
3500     case RF5_SPELL_START + 26: return spell_RF5_MISSILE(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF5_MISSILE */
3501     case RF5_SPELL_START + 27: spell_RF5_SCARE(m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF5_SCARE */
3502     case RF5_SPELL_START + 28: spell_RF5_BLIND(m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF5_BLIND */
3503     case RF5_SPELL_START + 29: spell_RF5_CONF(m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF5_CONF */
3504     case RF5_SPELL_START + 30: spell_RF5_SLOW(m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF5_SLOW */
3505     case RF5_SPELL_START + 31: spell_RF5_HOLD(m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF5_HOLD */
3506     case RF6_SPELL_START + 0:  spell_RF6_HASTE(m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_HASTE */
3507     case RF6_SPELL_START + 1:  return spell_RF6_HAND_DOOM(y, x, m_idx, 0, MONSTER_TO_PLAYER); /* RF6_HAND_DOOM */
3508     case RF6_SPELL_START + 2:  spell_RF6_HEAL(m_idx, 0, MONSTER_TO_PLAYER); break;    /* RF6_HEAL */
3509     case RF6_SPELL_START + 3:  spell_RF6_INVULNER(m_idx, 0, MONSTER_TO_PLAYER); break;    /* RF6_INVULNER */
3510     case RF6_SPELL_START + 4:  spell_RF6_BLINK(m_idx, MONSTER_TO_PLAYER); break;   /* RF6_BLINK */
3511     case RF6_SPELL_START + 5:  spell_RF6_TPORT(m_idx, MONSTER_TO_PLAYER); break;   /* RF6_TPORT */
3512     case RF6_SPELL_START + 6:  return spell_RF6_WORLD(m_idx); break;    /* RF6_WORLD */
3513     case RF6_SPELL_START + 7:  return spell_RF6_SPECIAL(y, x, m_idx, 0, MONSTER_TO_PLAYER);   /* RF6_SPECIAL */
3514     case RF6_SPELL_START + 8:  spell_RF6_TELE_TO(m_idx, 0, MONSTER_TO_PLAYER); break; /* RF6_TELE_TO */
3515     case RF6_SPELL_START + 9:  spell_RF6_TELE_AWAY(m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_TELE_AWAY */
3516     case RF6_SPELL_START + 10: spell_RF6_TELE_LEVEL(m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF6_TELE_LEVEL */
3517     case RF6_SPELL_START + 11: spell_RF6_PSY_SPEAR(y, x, m_idx, 0, MONSTER_TO_PLAYER); break; /* RF6_PSY_SPEAR */
3518     case RF6_SPELL_START + 12: spell_RF6_DARKNESS(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;    /* RF6_DARKNESS */
3519     case RF6_SPELL_START + 13: spell_RF6_TRAPS(y, x, m_idx); break; /* RF6_TRAPS */
3520     case RF6_SPELL_START + 14: spell_RF6_FORGET(m_idx); break;  /* RF6_FORGET */
3521     case RF6_SPELL_START + 15: spell_RF6_RAISE_DEAD(m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF6_RAISE_DEAD */
3522     case RF6_SPELL_START + 16: spell_RF6_S_KIN(y, x, m_idx, 0, MONSTER_TO_PLAYER); break; /* RF6_S_KIN */
3523     case RF6_SPELL_START + 17: spell_RF6_S_CYBER(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_CYBER */
3524     case RF6_SPELL_START + 18: spell_RF6_S_MONSTER(y, x, m_idx, 0, MONSTER_TO_PLAYER); break; /* RF6_S_MONSTER */
3525     case RF6_SPELL_START + 19: spell_RF6_S_MONSTERS(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;    /* RF6_S_MONSTER */
3526     case RF6_SPELL_START + 20: spell_RF6_S_ANT(y, x, m_idx, 0, MONSTER_TO_PLAYER); break; /* RF6_S_ANT */
3527     case RF6_SPELL_START + 21: spell_RF6_S_SPIDER(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF6_S_SPIDER */
3528     case RF6_SPELL_START + 22: spell_RF6_S_HOUND(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_HOUND */
3529     case RF6_SPELL_START + 23: spell_RF6_S_HYDRA(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_HYDRA */
3530     case RF6_SPELL_START + 24: spell_RF6_S_ANGEL(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_ANGEL */
3531     case RF6_SPELL_START + 25: spell_RF6_S_DEMON(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_DEMON */
3532     case RF6_SPELL_START + 26: spell_RF6_S_UNDEAD(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF6_S_UNDEAD */
3533     case RF6_SPELL_START + 27: spell_RF6_S_DRAGON(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF6_S_DRAGON */
3534     case RF6_SPELL_START + 28: spell_RF6_S_HI_UNDEAD(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_HI_UNDEAD */
3535     case RF6_SPELL_START + 29: spell_RF6_S_HI_DRAGON(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_HI_DRAGON */
3536     case RF6_SPELL_START + 30: spell_RF6_S_AMBERITES(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;   /* RF6_S_AMBERITES */
3537     case RF6_SPELL_START + 31: spell_RF6_S_UNIQUE(y, x, m_idx, 0, MONSTER_TO_PLAYER); break;  /* RF6_S_UNIQUE */
3538     }
3539     return 0;
3540 }
3541
3542 /*!
3543 * @brief モンスターからモンスターへの呪文の振り分け関数。 /
3544 * @param SPELL_NUM モンスター魔法ID
3545 * @param y 対象の地点のy座標
3546 * @param x 対象の地点のx座標
3547 * @param m_idx 呪文を唱えるモンスターID
3548 * @param t_idx 呪文を受けるモンスターID。プレイヤーの場合はdummyで0とする。
3549 * @return 攻撃呪文のダメージ、または召喚したモンスターの数を返す。その他の場合0。以降の処理を中断するなら-1を返す。
3550 */
3551 int monspell_to_monster(int SPELL_NUM, int y, int x, int m_idx, int t_idx)
3552 {
3553     switch (SPELL_NUM)
3554     {
3555     case RF4_SPELL_START + 0:   spell_RF4_SHRIEK(m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF4_SHRIEK */
3556     case RF4_SPELL_START + 1:   return -1;   /* RF4_XXX1 */
3557     case RF4_SPELL_START + 2:   spell_RF4_DISPEL(m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF4_DISPEL */
3558     case RF4_SPELL_START + 3:   return spell_RF4_ROCKET(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_ROCKET */
3559     case RF4_SPELL_START + 4:   return spell_RF4_SHOOT(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);  /* RF4_SHOOT */
3560     case RF4_SPELL_START + 5:   return -1;   /* RF4_XXX2 */
3561     case RF4_SPELL_START + 6:   return -1;   /* RF4_XXX3 */
3562     case RF4_SPELL_START + 7:   return -1;   /* RF4_XXX4 */
3563     case RF4_SPELL_START + 8:   return spell_RF4_BREATH(GF_ACID, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_ACID */
3564     case RF4_SPELL_START + 9:   return spell_RF4_BREATH(GF_ELEC, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_ELEC */
3565     case RF4_SPELL_START + 10:  return spell_RF4_BREATH(GF_FIRE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_FIRE */
3566     case RF4_SPELL_START + 11:  return spell_RF4_BREATH(GF_COLD, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_COLD */
3567     case RF4_SPELL_START + 12:  return spell_RF4_BREATH(GF_POIS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_POIS */
3568     case RF4_SPELL_START + 13:  return spell_RF4_BREATH(GF_NETHER, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);  /* RF4_BR_NETH */
3569     case RF4_SPELL_START + 14:  return spell_RF4_BREATH(GF_LITE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_LITE */
3570     case RF4_SPELL_START + 15:  return spell_RF4_BREATH(GF_DARK, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_DARK */
3571     case RF4_SPELL_START + 16:  return spell_RF4_BREATH(GF_CONFUSION, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);   /* RF4_BR_CONF */
3572     case RF4_SPELL_START + 17:  return spell_RF4_BREATH(GF_SOUND, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);   /* RF4_BR_SOUN */
3573     case RF4_SPELL_START + 18:  return spell_RF4_BREATH(GF_CHAOS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);   /* RF4_BR_CHAO */
3574     case RF4_SPELL_START + 19:  return spell_RF4_BREATH(GF_DISENCHANT, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);  /* RF4_BR_DISE */
3575     case RF4_SPELL_START + 20:  return spell_RF4_BREATH(GF_NEXUS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);   /* RF4_BR_NEXU */
3576     case RF4_SPELL_START + 21:  return spell_RF4_BREATH(GF_TIME, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_TIME */
3577     case RF4_SPELL_START + 22:  return spell_RF4_BREATH(GF_INERTIA, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_INER */
3578     case RF4_SPELL_START + 23:  return spell_RF4_BREATH(GF_GRAVITY, y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF4_BR_GRAV */
3579     case RF4_SPELL_START + 24:  return spell_RF4_BREATH(GF_SHARDS, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);  /* RF4_BR_SHAR */
3580     case RF4_SPELL_START + 25:  return spell_RF4_BREATH(GF_PLASMA, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);  /* RF4_BR_PLAS */
3581     case RF4_SPELL_START + 26:  return spell_RF4_BREATH(GF_FORCE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);   /* RF4_BR_WALL */
3582     case RF4_SPELL_START + 27:  return spell_RF4_BREATH(GF_MANA, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_MANA */
3583     case RF4_SPELL_START + 28:  return spell_RF4_BA_NUKE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BA_NUKE */
3584     case RF4_SPELL_START + 29:  return spell_RF4_BREATH(GF_NUKE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_NUKE */
3585     case RF4_SPELL_START + 30:  return spell_RF4_BA_CHAO(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BA_CHAO */
3586     case RF4_SPELL_START + 31:  return spell_RF4_BREATH(GF_DISINTEGRATE, y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF4_BR_DISI */
3587     case RF5_SPELL_START + 0:  return spell_RF5_BA_ACID(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_ACID */
3588     case RF5_SPELL_START + 1:  return spell_RF5_BA_ELEC(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_ELEC */
3589     case RF5_SPELL_START + 2:  return spell_RF5_BA_FIRE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_FIRE */
3590     case RF5_SPELL_START + 3:  return spell_RF5_BA_COLD(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_COLD */
3591     case RF5_SPELL_START + 4:  return spell_RF5_BA_POIS(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_POIS */
3592     case RF5_SPELL_START + 5:  return spell_RF5_BA_NETH(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_NETH */
3593     case RF5_SPELL_START + 6:  return spell_RF5_BA_WATE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_WATE */
3594     case RF5_SPELL_START + 7:  return spell_RF5_BA_MANA(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_MANA */
3595     case RF5_SPELL_START + 8:  return spell_RF5_BA_DARK(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_DARK */
3596     case RF5_SPELL_START + 9:  return spell_RF5_DRAIN_MANA(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF5_DRAIN_MANA */
3597     case RF5_SPELL_START + 10: return spell_RF5_MIND_BLAST(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF5_MIND_BLAST */
3598     case RF5_SPELL_START + 11: return spell_RF5_BRAIN_SMASH(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BRAIN_SMASH */
3599     case RF5_SPELL_START + 12: return spell_RF5_CAUSE_1(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_CAUSE_1 */
3600     case RF5_SPELL_START + 13: return spell_RF5_CAUSE_2(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_CAUSE_2 */
3601     case RF5_SPELL_START + 14: return spell_RF5_CAUSE_3(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_CAUSE_3 */
3602     case RF5_SPELL_START + 15: return spell_RF5_CAUSE_4(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_CAUSE_4 */
3603     case RF5_SPELL_START + 16: return spell_RF5_BO_ACID(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_ACID */
3604     case RF5_SPELL_START + 17: return spell_RF5_BO_ELEC(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_ELEC */
3605     case RF5_SPELL_START + 18: return spell_RF5_BO_FIRE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_FIRE */
3606     case RF5_SPELL_START + 19: return spell_RF5_BO_COLD(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_COLD */
3607     case RF5_SPELL_START + 20: return spell_RF5_BA_LITE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BA_LITE */
3608     case RF5_SPELL_START + 21: return spell_RF5_BO_NETH(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_NETH */
3609     case RF5_SPELL_START + 22: return spell_RF5_BO_WATE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_WATE */
3610     case RF5_SPELL_START + 23: return spell_RF5_BO_MANA(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_MANA */
3611     case RF5_SPELL_START + 24: return spell_RF5_BO_PLAS(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_PLAS */
3612     case RF5_SPELL_START + 25: return spell_RF5_BO_ICEE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_BO_ICEE */
3613     case RF5_SPELL_START + 26: return spell_RF5_MISSILE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);    /* RF5_MISSILE */
3614     case RF5_SPELL_START + 27: spell_RF5_SCARE(m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF5_SCARE */
3615     case RF5_SPELL_START + 28: spell_RF5_BLIND(m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF5_BLIND */
3616     case RF5_SPELL_START + 29: spell_RF5_CONF(m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF5_CONF */
3617     case RF5_SPELL_START + 30: spell_RF5_SLOW(m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF5_SLOW */
3618     case RF5_SPELL_START + 31: spell_RF5_HOLD(m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF5_HOLD */
3619     case RF6_SPELL_START + 0:  spell_RF6_HASTE(m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_HASTE */
3620     case RF6_SPELL_START + 1:  return spell_RF6_HAND_DOOM(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); /* RF6_HAND_DOOM */
3621     case RF6_SPELL_START + 2:  spell_RF6_HEAL(m_idx, t_idx, MONSTER_TO_MONSTER); break;    /* RF6_HEAL */
3622     case RF6_SPELL_START + 3:  spell_RF6_INVULNER(m_idx, t_idx, MONSTER_TO_MONSTER); break;    /* RF6_INVULNER */
3623     case RF6_SPELL_START + 4:  spell_RF6_BLINK(m_idx, MONSTER_TO_MONSTER); break;   /* RF6_BLINK */
3624     case RF6_SPELL_START + 5:  spell_RF6_TPORT(m_idx, MONSTER_TO_MONSTER); break;   /* RF6_TPORT */
3625     case RF6_SPELL_START + 6:  return -1; break;    /* RF6_WORLD */
3626     case RF6_SPELL_START + 7:  return spell_RF6_SPECIAL(y, x, m_idx, t_idx, MONSTER_TO_MONSTER);   /* RF6_SPECIAL */
3627     case RF6_SPELL_START + 8:  spell_RF6_TELE_TO(m_idx, t_idx, MONSTER_TO_MONSTER); break; /* RF6_TELE_TO */
3628     case RF6_SPELL_START + 9:  spell_RF6_TELE_AWAY(m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_TELE_AWAY */
3629     case RF6_SPELL_START + 10: spell_RF6_TELE_LEVEL(m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF6_TELE_LEVEL */
3630     case RF6_SPELL_START + 11: spell_RF6_PSY_SPEAR(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break; /* RF6_PSY_SPEAR */
3631     case RF6_SPELL_START + 12: spell_RF6_DARKNESS(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;    /* RF6_DARKNESS */
3632     case RF6_SPELL_START + 13: return -1; /* RF6_TRAPS */
3633     case RF6_SPELL_START + 14: return -1;  /* RF6_FORGET */
3634     case RF6_SPELL_START + 15: spell_RF6_RAISE_DEAD(m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF6_RAISE_DEAD */
3635     case RF6_SPELL_START + 16: spell_RF6_S_KIN(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break; /* RF6_S_KIN */
3636     case RF6_SPELL_START + 17: spell_RF6_S_CYBER(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_CYBER */
3637     case RF6_SPELL_START + 18: spell_RF6_S_MONSTER(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break; /* RF6_S_MONSTER */
3638     case RF6_SPELL_START + 19: spell_RF6_S_MONSTERS(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;    /* RF6_S_MONSTER */
3639     case RF6_SPELL_START + 20: spell_RF6_S_ANT(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break; /* RF6_S_ANT */
3640     case RF6_SPELL_START + 21: spell_RF6_S_SPIDER(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF6_S_SPIDER */
3641     case RF6_SPELL_START + 22: spell_RF6_S_HOUND(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_HOUND */
3642     case RF6_SPELL_START + 23: spell_RF6_S_HYDRA(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_HYDRA */
3643     case RF6_SPELL_START + 24: spell_RF6_S_ANGEL(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_ANGEL */
3644     case RF6_SPELL_START + 25: spell_RF6_S_DEMON(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_DEMON */
3645     case RF6_SPELL_START + 26: spell_RF6_S_UNDEAD(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF6_S_UNDEAD */
3646     case RF6_SPELL_START + 27: spell_RF6_S_DRAGON(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF6_S_DRAGON */
3647     case RF6_SPELL_START + 28: spell_RF6_S_HI_UNDEAD(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_HI_UNDEAD */
3648     case RF6_SPELL_START + 29: spell_RF6_S_HI_DRAGON(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_HI_DRAGON */
3649     case RF6_SPELL_START + 30: spell_RF6_S_AMBERITES(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;   /* RF6_S_AMBERITES */
3650     case RF6_SPELL_START + 31: spell_RF6_S_UNIQUE(y, x, m_idx, t_idx, MONSTER_TO_MONSTER); break;  /* RF6_S_UNIQUE */
3651     }
3652     return 0;
3653 }
3654
3655 /*!
3656 * @brief モンスターの使う呪文の威力を決定する /
3657 * @param dam 定数値
3658 * @param dice_num ダイス数
3659 * @param dice_side ダイス面
3660 * @param mult ダイス倍率
3661 * @param div ダイス倍率
3662 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
3663 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
3664 */
3665 int monspell_damage_roll(int dam, int dice_num, int dice_side, int mult, int div, int TYPE)
3666 {
3667     switch (TYPE)
3668     {
3669         case DAM_MAX: dam += maxroll(dice_num, dice_side) * mult / div; break;
3670         case DAM_MIN: dam += dice_num * 1 * mult / div; break;
3671         case DAM_ROLL: dam += damroll(dice_num, dice_side) * mult / div; break;
3672         case DICE_NUM: return dice_num;
3673         case DICE_SIDE: return dice_side;
3674         case DICE_MULT: return mult;
3675         case DICE_DIV: return div;
3676         case BASE_DAM: return dam;
3677     }
3678     if (dam < 1) dam = 1;
3679     return dam;
3680 }
3681
3682 /*!
3683 * @brief モンスターの使う呪文の威力を返す /
3684 * @param SPELL_NUM 呪文番号
3685 * @param hp 呪文を唱えるモンスターの体力
3686 * @param rlev 呪文を唱えるモンスターのレベル
3687 * @param powerful 呪文を唱えるモンスターのpowerfulフラグ
3688 * @param shoot_dd 射撃のダイス数
3689 * @param shoot_ds 射撃のダイス面
3690 * @param shoot_base 射撃の固定威力値
3691 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
3692 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
3693 */
3694 int monspell_damage_base(int SPELL_NUM, int hp, int rlev, bool powerful, int shoot_dd, int shoot_ds, int shoot_base, int TYPE)
3695 {
3696     int dam = 0, dice_num = 0, dice_side = 0, mult = 1, div = 1;
3697
3698     switch (SPELL_NUM)
3699     {
3700     case MS_SHRIEK:   return -1;   /* RF4_SHRIEK */
3701     case MS_XXX1:   return -1;   /* RF4_XXX1 */
3702     case MS_DISPEL:   return -1;   /* RF4_DISPEL */
3703
3704         /* RF4_ROCKET */
3705     case MS_ROCKET:
3706         dam = (hp / 4) > 800 ? 800 : (hp / 4);
3707         break;
3708
3709         /* RF4_SHOOT */
3710     case MS_SHOOT:
3711         dice_num = shoot_dd;
3712         dice_side = shoot_ds;
3713         dam = shoot_base;
3714         break;
3715     case MS_XXX2:   return -1;   /* RF4_XXX2 */
3716     case MS_XXX3:   return -1;   /* RF4_XXX3 */
3717     case MS_XXX4:   return -1;   /* RF4_XXX4 */
3718
3719         /* RF4_BR_ACID */
3720         /* RF4_BR_ELEC */
3721         /* RF4_BR_FIRE */
3722         /* RF4_BR_COLD */
3723     case MS_BR_ACID:
3724     case MS_BR_ELEC:
3725     case MS_BR_FIRE:
3726     case MS_BR_COLD:
3727         dam = ((hp / 3) > 1600 ? 1600 : (hp / 3));
3728         break;
3729
3730         /* RF4_BR_POIS */
3731     case MS_BR_POIS:
3732         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
3733         break;
3734
3735         /* RF4_BR_NETH */
3736     case MS_BR_NETHER:
3737         dam = ((hp / 6) > 550 ? 550 : (hp / 6));
3738         break;
3739
3740         /* RF4_BR_LITE */
3741         /* RF4_BR_DARK */
3742     case MS_BR_LITE:
3743     case MS_BR_DARK:
3744         dam = ((hp / 6) > 400 ? 400 : (hp / 6));
3745         break;
3746
3747         /* RF4_BR_CONF */
3748         /* RF4_BR_SOUN */
3749     case MS_BR_CONF:
3750     case MS_BR_SOUND:
3751         dam = ((hp / 6) > 450 ? 450 : (hp / 6));
3752         break;
3753
3754         /* RF4_BR_CHAO */
3755     case MS_BR_CHAOS:
3756         dam = ((hp / 6) > 600 ? 600 : (hp / 6));
3757         break;
3758
3759         /* RF4_BR_DISE */
3760     case MS_BR_DISEN:
3761         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
3762         break;
3763
3764         /* RF4_BR_NEXU */
3765     case MS_BR_NEXUS:
3766         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
3767         break;
3768
3769         /* RF4_BR_TIME */
3770     case MS_BR_TIME:
3771         dam = ((hp / 3) > 150 ? 150 : (hp / 3));
3772         break;
3773
3774         /* RF4_BR_INER */
3775         /* RF4_BR_GRAV */
3776     case MS_BR_INERTIA:
3777     case MS_BR_GRAVITY:
3778         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
3779         break;
3780
3781         /* RF4_BR_SHAR */
3782     case MS_BR_SHARDS:
3783         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
3784         break;
3785
3786         /* RF4_BR_PLAS */
3787     case MS_BR_PLASMA:
3788         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
3789         break;
3790
3791         /* RF4_BR_WALL */
3792     case MS_BR_FORCE:
3793         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
3794         break;
3795
3796         /* RF4_BR_MANA */
3797     case MS_BR_MANA:
3798         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
3799         break;
3800
3801         /* RF4_BA_NUKE */
3802     case MS_BALL_NUKE:
3803         mult = powerful ? 2 : 1;
3804         dam = rlev * (mult / div);
3805         dice_num = 10;
3806         dice_side = 6;
3807         break;
3808
3809         /* RF4_BR_NUKE */
3810     case MS_BR_NUKE:
3811         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
3812         break;
3813
3814         /* RF4_BA_CHAO */
3815     case MS_BALL_CHAOS:
3816         dam = (powerful ? (rlev * 3) : (rlev * 2));
3817         dice_num = 10;
3818         dice_side = 10;
3819         break;
3820
3821         /* RF4_BR_DISI */
3822     case MS_BR_DISI:
3823         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
3824         break;
3825
3826         /* RF5_BA_ACID */
3827     case MS_BALL_ACID:
3828         if (powerful)
3829         {
3830             dam = (rlev * 4) + 50;
3831             dice_num = 10;
3832             dice_side = 10;
3833         }
3834         else
3835         {
3836             dam = 15;
3837             dice_num = 1;
3838             dice_side = rlev * 3;
3839         }
3840         break;
3841
3842         /* RF5_BA_ELEC */
3843     case MS_BALL_ELEC:
3844         if (powerful)
3845         {
3846             dam = (rlev * 4) + 50;
3847             dice_num = 10;
3848             dice_side = 10;
3849         }
3850         else
3851         {
3852             dam = 8;
3853             dice_num = 1;
3854             dice_side = rlev * 3 / 2;
3855         }
3856         break;
3857
3858         /* RF5_BA_FIRE */
3859     case MS_BALL_FIRE:
3860         if (powerful)
3861         {
3862             dam = (rlev * 4) + 50;
3863             dice_num = 10;
3864             dice_side = 10;
3865         }
3866         else
3867         {
3868             dam = 10;
3869             dice_num = 1;
3870             dice_side = rlev * 7 / 2;
3871         }
3872         break;
3873
3874         /* RF5_BA_COLD */
3875     case MS_BALL_COLD:
3876         if (powerful)
3877         {
3878             dam = (rlev * 4) + 50;
3879             dice_num = 10;
3880             dice_side = 10;
3881         }
3882         else
3883         {
3884             dam = 10;
3885             dice_num = 1;
3886             dice_side = rlev * 3 / 2;
3887         }
3888         break;
3889
3890         /* RF5_BA_POIS */
3891     case MS_BALL_POIS:
3892         mult = powerful ? 2 : 1;
3893         dice_num = 12;
3894         dice_side = 2;
3895         break;
3896
3897         /* RF5_BA_NETH */
3898     case MS_BALL_NETHER:
3899         dam = 50 + rlev * (powerful ? 2 : 1);
3900         dice_num = 10;
3901         dice_side = 10;
3902         break;
3903
3904         /* RF5_BA_WATE */
3905     case MS_BALL_WATER:
3906         dam = 50;
3907         dice_num = 1;
3908         dice_side = powerful ? (rlev * 3) : (rlev * 2);
3909         break;
3910
3911         /* RF5_BA_MANA */
3912         /* RF5_BA_DARK */
3913     case MS_BALL_MANA:
3914     case MS_BALL_DARK:
3915         dam = (rlev * 4) + 50;
3916         dice_num = 10;
3917         dice_side = 10;
3918         break;
3919
3920         /* RF5_DRAIN_MANA */
3921     case MS_DRAIN_MANA:
3922         dam = rlev;
3923         div = 1;
3924         dice_num = 1;
3925         dice_side = rlev;
3926         break;
3927
3928         /* RF5_MIND_BLAST */
3929     case MS_MIND_BLAST:
3930         dice_num = 7;
3931         dice_side = 7;
3932         break;
3933
3934         /* RF5_BRAIN_SMASH */
3935     case MS_BRAIN_SMASH:
3936         dice_num = 12;
3937         dice_side = 12;
3938         break;
3939
3940         /* RF5_CAUSE_1 */
3941     case MS_CAUSE_1:
3942         dice_num = 3;
3943         dice_side = 8;
3944         break;
3945
3946         /* RF5_CAUSE_2 */
3947     case MS_CAUSE_2:
3948         dice_num = 8;
3949         dice_side = 8;
3950         break;
3951
3952         /* RF5_CAUSE_3 */
3953     case MS_CAUSE_3:
3954         dice_num = 10;
3955         dice_side = 15;
3956         break;
3957
3958         /* RF5_CAUSE_4 */
3959     case MS_CAUSE_4:
3960         dice_num = 15;
3961         dice_side = 15;
3962         break;
3963
3964         /* RF5_BO_ACID */
3965     case MS_BOLT_ACID:
3966         mult = powerful ? 2 : 1;
3967         dam = rlev / 3 * (mult / div);
3968         dice_num = 7;
3969         dice_side = 8;
3970         break;
3971
3972         /* RF5_BO_ELEC */
3973     case MS_BOLT_ELEC:
3974         mult = powerful ? 2 : 1;
3975         dam = rlev / 3 * (mult / div);
3976         dice_num = 4;
3977         dice_side = 8;
3978         break;
3979
3980         /* RF5_BO_FIRE */
3981     case MS_BOLT_FIRE:
3982         mult = powerful ? 2 : 1;
3983         dam = rlev / 3 * (mult / div);
3984         dice_num = 9;
3985         dice_side = 8;
3986         break;
3987
3988         /* RF5_BO_COLD */
3989     case MS_BOLT_COLD:
3990         mult = powerful ? 2 : 1;
3991         dam = rlev / 3 * (mult / div);
3992         dice_num = 6;
3993         dice_side = 8;
3994         break;
3995
3996         /* RF5_BA_LITE */
3997     case MS_STARBURST:
3998         dam = (rlev * 4) + 50;
3999         dice_num = 10;
4000         dice_side = 10;
4001         break;
4002
4003         /* RF5_BO_NETH */
4004     case MS_BOLT_NETHER:
4005         dam = 30 + (rlev * 4) / (powerful ? 2 : 3);
4006         dice_num = 5;
4007         dice_side = 5;
4008         break;
4009
4010         /* RF5_BO_WATE */
4011     case MS_BOLT_WATER:
4012         dam = (rlev * 3 / (powerful ? 2 : 3));
4013         dice_num = 10;
4014         dice_side = 10;
4015         break;
4016
4017         /* RF5_BO_MANA */
4018     case MS_BOLT_MANA:
4019         dam = 50;
4020         dice_num = 1;
4021         dice_side = rlev * 7 / 2;
4022         break;
4023
4024         /* RF5_BO_PLAS */
4025     case MS_BOLT_PLASMA:
4026         dam = 10 + (rlev * 3 / (powerful ? 2 : 3));
4027         dice_num = 8;
4028         dice_side = 7;
4029         break;
4030
4031         /* RF5_BO_ICEE */
4032     case MS_BOLT_ICE:
4033         dam = (rlev * 3 / (powerful ? 2 : 3));
4034         dice_num = 6;
4035         dice_side = 6;
4036         break;
4037
4038         /* RF5_MISSILE */
4039     case MS_MAGIC_MISSILE:
4040         dam = (rlev / 3);
4041         dice_num = 2;
4042         dice_side = 6;
4043         break;
4044
4045     case MS_SCARE: return -1;   /* RF5_SCARE */
4046     case MS_BLIND: return -1;   /* RF5_BLIND */
4047     case MS_CONF: return -1;   /* RF5_CONF */
4048     case MS_SLOW: return -1;   /* RF5_SLOW */
4049     case MS_SLEEP: return -1;   /* RF5_HOLD */
4050     case MS_SPEED:  return -1;   /* RF6_HASTE */
4051
4052         /* RF6_HAND_DOOM */
4053     case MS_HAND_DOOM:
4054         mult = p_ptr->chp;
4055         div = 100;
4056         dam = 40 * (mult / div);
4057         dice_num = 1;
4058         dice_side = 20;
4059         break;
4060
4061     case MS_HEAL:  return -1;   /* RF6_HEAL */
4062     case MS_INVULNER:  return -1;   /* RF6_INVULNER */
4063     case MS_BLINK:  return -1;   /* RF6_BLINK */
4064     case MS_TELEPORT:  return -1;   /* RF6_TPORT */
4065     case MS_WORLD:  return -1;   /* RF6_WORLD */
4066     case MS_SPECIAL:  return -1;   /* RF6_SPECIAL */
4067     case MS_TELE_TO:  return -1;   /* RF6_TELE_TO */
4068     case MS_TELE_AWAY:  return -1;   /* RF6_TELE_AWAY */
4069     case MS_TELE_LEVEL: return -1;   /* RF6_TELE_LEVEL */
4070
4071         /* RF6_PSY_SPEAR */
4072     case MS_PSY_SPEAR:
4073         dam = powerful ? 150 : 100;
4074         dice_num = 1;
4075         dice_side = powerful ? (rlev * 2) : (rlev * 3 / 2);
4076         break;
4077
4078     case MS_DARKNESS: return -1;   /* RF6_DARKNESS */
4079     case MS_MAKE_TRAP: return -1;   /* RF6_TRAPS */
4080     case MS_FORGET: return -1;   /* RF6_FORGET */
4081     case MS_RAISE_DEAD: return -1;   /* RF6_RAISE_DEAD */
4082     case MS_S_KIN: return -1;   /* RF6_S_KIN */
4083     case MS_S_CYBER: return -1;   /* RF6_S_CYBER */
4084     case MS_S_MONSTER: return -1;   /* RF6_S_MONSTER */
4085     case MS_S_MONSTERS: return -1;   /* RF6_S_MONSTER */
4086     case MS_S_ANT: return -1;   /* RF6_S_ANT */
4087     case MS_S_SPIDER: return -1;   /* RF6_S_SPIDER */
4088     case MS_S_HOUND: return -1;   /* RF6_S_HOUND */
4089     case MS_S_HYDRA: return -1;   /* RF6_S_HYDRA */
4090     case MS_S_ANGEL: return -1;   /* RF6_S_ANGEL */
4091     case MS_S_DEMON: return -1;   /* RF6_S_DEMON */
4092     case MS_S_UNDEAD: return -1;   /* RF6_S_UNDEAD */
4093     case MS_S_DRAGON: return -1;   /* RF6_S_DRAGON */
4094     case MS_S_HI_UNDEAD: return -1;   /* RF6_S_HI_UNDEAD */
4095     case MS_S_HI_DRAGON: return -1;   /* RF6_S_HI_DRAGON */
4096     case MS_S_AMBERITE: return -1;   /* RF6_S_AMBERITES */
4097     case MS_S_UNIQUE: return -1;   /* RF6_S_UNIQUE */
4098     }
4099
4100     return monspell_damage_roll(dam, dice_num, dice_side, mult, div, TYPE);
4101 }
4102
4103
4104 /*!
4105 * @brief モンスターの使う呪文の威力を返す /
4106 * @param SPELL_NUM 呪文番号
4107 * @param m_idx 呪文を唱えるモンスターID
4108 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
4109 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
4110 */
4111 int monspell_damage(int SPELL_NUM, int m_idx, int TYPE)
4112 {
4113     monster_type    *m_ptr = &m_list[m_idx];
4114     monster_race    *r_ptr = &r_info[m_ptr->r_idx];
4115     int hp;
4116     int rlev = monster_level_idx(m_idx);
4117     int shoot_dd = r_ptr->blow[0].d_dice;
4118     int shoot_ds = r_ptr->blow[0].d_side;
4119
4120     if (TYPE == DAM_ROLL)
4121     {
4122         hp = m_ptr->hp;
4123     }
4124     else
4125     {
4126         hp = m_ptr->max_maxhp;
4127     }
4128     return monspell_damage_base(SPELL_NUM, hp, rlev, monster_is_powerful(m_idx), shoot_dd, shoot_ds, 0, TYPE);
4129 }
4130
4131 /*!
4132 * @brief モンスターの使う呪文の威力を返す /
4133 * @param SPELL_NUM 呪文番号
4134 * @param r_idx 呪文を唱えるモンスターの種族ID
4135 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
4136 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
4137 */
4138 int monspell_race_damage(int SPELL_NUM, int r_idx, int TYPE)
4139 {
4140     monster_race    *r_ptr = &r_info[r_idx];
4141     int rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
4142     bool powerful = r_ptr->flags2 & RF2_POWERFUL ? TRUE : FALSE;
4143     u32b hp = r_ptr->hdice * (ironman_nightmare ? 2 : 1) * r_ptr->hside;
4144     int shoot_dd = r_ptr->blow[0].d_dice;
4145     int shoot_ds = r_ptr->blow[0].d_side;
4146
4147     return monspell_damage_base(SPELL_NUM, MIN(30000, hp), rlev, powerful, shoot_dd, shoot_ds, 0, TYPE);
4148 }
4149
4150 /*!
4151 * @brief 青魔導師の使う呪文の威力を返す /
4152 * @param SPELL_NUM 呪文番号
4153 * @param plev 使用するレベル。2倍して扱う。
4154 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
4155 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
4156 */
4157 int monspell_bluemage_damage(int SPELL_NUM, int plev, int TYPE)
4158 {
4159     int hp = p_ptr->chp;
4160     int shoot_dd = 1, shoot_ds = 1, shoot_base = 0;
4161     object_type *o_ptr = NULL;
4162
4163     if (buki_motteruka(INVEN_RARM)) o_ptr = &inventory[INVEN_RARM];
4164     else if (buki_motteruka(INVEN_LARM)) o_ptr = &inventory[INVEN_LARM];
4165
4166     if (o_ptr)
4167     {
4168         shoot_dd = o_ptr->dd;
4169         shoot_ds = o_ptr->ds;
4170         shoot_base = o_ptr->to_d;
4171     }
4172     return monspell_damage_base(SPELL_NUM, hp, plev * 2, FALSE, shoot_dd, shoot_ds, shoot_base, TYPE);
4173 }