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