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