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