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