src/mind/mind-elementalist.cpp

   1 /*!
   2  * @brief 元素使いの魔法系統
   3  */
   4
   5 #include "mind-elementalist.h"
   6 #include "action/action-limited.h"
   7 #include "avatar/avatar.h"
   8 #include "cmd-action/cmd-mind.h"
   9 #include "cmd-action/cmd-spell.h"
  10 #include "cmd-io/cmd-gameoption.h"
  11 #include "core/asking-player.h"
  12 #include "core/player-redraw-types.h"
  13 #include "core/stuff-handler.h"
  14 #include "core/window-redrawer.h"
  15 #include "effect/effect-characteristics.h"
  16 #include "effect/effect-monster-util.h"
  17 #include "effect/effect-processor.h"
  18 #include "effect/spells-effect-util.h"
  19 #include "floor/cave.h"
  20 #include "floor/floor-util.h"
  21 #include "floor/geometry.h"
  22 #include "game-option/disturbance-options.h"
  23 #include "game-option/input-options.h"
  24 #include "game-option/text-display-options.h"
  25 #include "grid/feature-flag-types.h"
  26 #include "grid/grid.h"
  27 #include "hpmp/hp-mp-processor.h"
  28 #include "io/command-repeater.h"
  29 #include "io/input-key-acceptor.h"
  30 #include "io/input-key-requester.h"
  31 #include "main/sound-definitions-table.h"
  32 #include "main/sound-of-music.h"
  33 #include "mind/mind-explanations-table.h"
  34 #include "mind/mind-mindcrafter.h"
  35 #include "monster-race/monster-race.h"
  36 #include "monster-race/race-flags-resistance.h"
  37 #include "monster-race/race-flags3.h"
  38 #include "monster-race/race-flags7.h"
  39 #include "monster/monster-describer.h"
  40 #include "player-info/equipment-info.h"
  41 #include "player-status/player-energy.h"
  42 #include "player-status/player-status-base.h"
  43 #include "player/player-status-table.h"
  44 #include "racial/racial-util.h"
  45 #include "spell-kind/earthquake.h"
  46 #include "spell-kind/magic-item-recharger.h"
  47 #include "spell-kind/spells-beam.h"
  48 #include "spell-kind/spells-charm.h"
  49 #include "spell-kind/spells-detection.h"
  50 #include "spell-kind/spells-genocide.h"
  51 #include "spell-kind/spells-launcher.h"
  52 #include "spell-kind/spells-lite.h"
  53 #include "spell-kind/spells-sight.h"
  54 #include "spell-kind/spells-teleport.h"
  55 #include "spell-kind/spells-world.h"
  56 #include "effect/attribute-types.h"
  57 #include "status/bad-status-setter.h"
  58 #include "status/base-status.h"
  59 #include "system/floor-type-definition.h"
  60 #include "system/game-option-types.h"
  61 #include "system/grid-type-definition.h"
  62 #include "system/monster-race-definition.h"
  63 #include "system/monster-type-definition.h"
  64 #include "system/player-type-definition.h"
  65 #include "target/grid-selector.h"
  66 #include "target/target-getter.h"
  67 #include "term/screen-processor.h"
  68 #include "term/term-color-types.h"
  69 #include "timed-effect/player-stun.h"
  70 #include "timed-effect/timed-effects.h"
  71 #include "util/bit-flags-calculator.h"
  72 #include "util/buffer-shaper.h"
  73 #include "util/enum-converter.h"
  74 #include "util/int-char-converter.h"
  75 #include "view/display-messages.h"
  76 #include <array>
  77 #include <string>
  78 #include <unordered_map>
  79
  80 /*!
  81  * @brief 元素魔法呪文のID定義
  82  */
  83 enum class ElementSpells {
  84     BOLT_1ST = 0,
  85     MON_DETECT = 1,
  86     PERCEPT = 2,
  87     CURE = 3,
  88     BOLT_2ND = 4,
  89     MAG_DETECT = 5,
  90     BALL_3RD = 6,
  91     BALL_1ST = 7,
  92     BREATH_2ND = 8,
  93     ANNIHILATE = 9,
  94     BOLT_3RD = 10,
  95     WAVE_1ST = 11,
  96     BALL_2ND = 12,
  97     BURST_1ST = 13,
  98     STORM_2ND = 14,
  99     BREATH_1ST = 15,
 100     STORM_3ND = 16,
 101     MAX
 102 };
 103
 104 /*!
 105  * @brief 元素魔法タイプ構造体
 106  */
 107 struct element_type {
 108     std::string_view title; //!< 領域名
 109     std::array<AttributeType, 3> type; //!< 属性タイプリスト
 110     std::array<std::string_view, 3> name; //!< 属性名リスト
 111     std::unordered_map<AttributeType, AttributeType> extra; //!< 追加属性タイプ
 112 };
 113
 114 /*!
 115  * @brief 元素魔法難易度構造体
 116  */
 117 struct element_power {
 118     int elem; //!< 使用属性番号
 119     mind_type info; //!< 難易度構造体
 120 };
 121
 122 using element_type_list = const std::unordered_map<ElementRealmType, element_type>;
 123 using element_power_list = const std::unordered_map<ElementSpells, element_power>;
 124 using element_tip_list = const std::unordered_map<ElementSpells, std::string_view>;
 125 using element_text_list = const std::unordered_map<ElementRealmType, std::string_view>;
 126
 127 // clang-format off
 128 /*!
 129  * @brief 元素魔法タイプ定義
 130  */
 131 static element_type_list element_types = {
 132     {
 133         ElementRealmType::FIRE, {
 134             _("炎", "Fire"),
 135             { AttributeType::FIRE, AttributeType::HELL_FIRE, AttributeType::PLASMA },
 136             { _("火炎", "Fire"), _("業火", "Hell Fire"), _("プラズマ", "Plasma") },
 137             { },
 138         }
 139     },
 140     {
 141         ElementRealmType::ICE, {
 142             _("氷", "Ice"),
 143             { AttributeType::COLD, AttributeType::INERTIAL, AttributeType::TIME },
 144             { _("冷気", "Ice"), _("遅鈍", "Inertia"), _("時間逆転", "Time Stream") },
 145             { { AttributeType::COLD, AttributeType::ICE} },
 146         }
 147     },
 148     {
 149         ElementRealmType::SKY, {
 150             _("空", "Sky"),
 151             { AttributeType::ELEC, AttributeType::LITE, AttributeType::MANA },
 152             { _("電撃", "Lightning"), _("光", "Light"), _("魔力", "Mana") },
 153             { },
 154         }
 155     },
 156     {
 157         ElementRealmType::SEA, {
 158             _("海", "Sea"),
 159             { AttributeType::ACID, AttributeType::WATER, AttributeType::DISINTEGRATE },
 160             { _("酸", "Acid"), _("水", "Water"), _("分解", "Disintegration") },
 161             { },
 162         }
 163     },
 164     {
 165         ElementRealmType::DARKNESS, {
 166             _("闇", "Darkness"),
 167             { AttributeType::DARK, AttributeType::NETHER, AttributeType::VOID_MAGIC },
 168             { _("暗黒", "Darkness"), _("地獄", "Nether"), _("虚無", "void") },
 169             { { AttributeType::DARK, AttributeType::ABYSS } },
 170         }
 171     },
 172     {
 173         ElementRealmType::CHAOS, {
 174             _("混沌", "Chaos"),
 175             { AttributeType::CONFUSION, AttributeType::CHAOS, AttributeType::NEXUS },
 176             { _("混乱", "Confusion"), _("カオス", "Chaos"), _("因果混乱", "Nexus") },
 177             { },
 178         }
 179     },
 180     {
 181         ElementRealmType::EARTH, {
 182             _("地", "Earth"),
 183             { AttributeType::SHARDS, AttributeType::FORCE, AttributeType::METEOR },
 184             { _("破片", "Shards"), _("フォース", "Force"), _("隕石", "Meteor") },
 185             { },
 186         }
 187     },
 188     {
 189         ElementRealmType::DEATH, {
 190             _("瘴気", "Death"),
 191             { AttributeType::POIS, AttributeType::HYPODYNAMIA, AttributeType::DISENCHANT },
 192             { _("毒", "Poison"), _("吸血", "Drain Life"), _("劣化", "Disenchantment") },
 193             { },
 194         }
 195     },
 196 };
 197
 198 /*!
 199  * @brief 元素魔法呪文定義
 200  */
 201 static element_power_list element_powers = {
 202     { ElementSpells::BOLT_1ST,   { 0, {  1,  1,  15, _("%sの矢", "%s Bolt") }}},
 203     { ElementSpells::MON_DETECT, { 0, {  2,  2,  20, _("モンスター感知", "Detect Monsters") }}},
 204     { ElementSpells::PERCEPT,    { 0, {  5,  5,  50, _("擬似鑑定", "Psychometry") }}},
 205     { ElementSpells::CURE,       { 0, {  6,  5,  35, _("傷の治癒", "Cure Wounds") }}},
 206     { ElementSpells::BOLT_2ND,   { 1, {  8,  6,  35, _("%sの矢", "%s Bolt") }}},
 207     { ElementSpells::MAG_DETECT, { 0, { 10,  8,  60, _("魔法感知", "Detect Magical Objs") }}},
 208     { ElementSpells::BALL_3RD,   { 2, { 15, 10,  55, _("%s放射", "%s Spout") }}},
 209     { ElementSpells::BALL_1ST,   { 0, { 18, 13,  65, _("%sの球", "%s Ball") }}},
 210     { ElementSpells::BREATH_2ND, { 1, { 21, 20,  70, _("%sのブレス", "Breath of %s") }}},
 211     { ElementSpells::ANNIHILATE, { 0, { 24, 20,  75, _("モンスター消滅", "Annihilation") }}},
 212     { ElementSpells::BOLT_3RD,   { 2, { 25, 15,  60, _("%sの矢", "%s Bolt") }}},
 213     { ElementSpells::WAVE_1ST,   { 0, { 28, 30,  75, _("元素の波動", "Elemental Wave") }}},
 214     { ElementSpells::BALL_2ND,   { 1, { 28, 22,  75, _("%sの球", "%s Ball") }}},
 215     { ElementSpells::BURST_1ST,  { 0, { 33, 35,  75, _("精気乱射", "%s Blast") }}},
 216     { ElementSpells::STORM_2ND,  { 1, { 35, 30,  75, _("%sの嵐", "%s Storm") }}},
 217     { ElementSpells::BREATH_1ST, { 0, { 42, 48,  75, _("%sのブレス", "Breath of %s") }}},
 218     { ElementSpells::STORM_3ND,  { 2, { 45, 60,  80, _("%sの嵐", "%s Storm") }}},
 219 };
 220
 221 /*!
 222  * @brief 元素魔法呪文説明文定義
 223  */
 224 static element_tip_list element_tips = {
 225     { ElementSpells::BOLT_1ST,
 226     _("弱い%sの矢を放つ。", "Fire a weak bolt of %s.") },
 227     { ElementSpells::MON_DETECT,
 228     _("近くの全てのモンスターを感知する。", "Detects monsters.") },
 229     { ElementSpells::PERCEPT,
 230     _("アイテムの雰囲気を知る。", "Gives feeling of an item.") },
 231     { ElementSpells::CURE,
 232     _("怪我と体力を少し回復させる。", "Heals HP and wounds a bit.") },
 233     { ElementSpells::BOLT_2ND,
 234     _("%sの矢を放つ。", "Fire a bolt of %s.") },
 235     { ElementSpells::MAG_DETECT,
 236     _("近くの魔法のアイテムを感知する。", "Detects magic devices.") },
 237     { ElementSpells::BALL_3RD,
 238     _("高威力で射程が短い%sの球を放つ。", "Fire a strong, short-range, ball of %s.") },
 239     { ElementSpells::BALL_1ST,
 240     _("%sの球を放つ。",  "Fire a ball of %s.") },
 241     { ElementSpells::BREATH_2ND,
 242     _("%sのブレスを吐く。", "Fire a breath of %s.") },
 243     { ElementSpells::ANNIHILATE,
 244     _("%s耐性のないモンスターを1体抹殺する。", "Erase a monster unless it resists %s.") },
 245     { ElementSpells::BOLT_3RD,
 246     _("%sの矢を放つ。", "Fire a bolt of %s.") },
 247     { ElementSpells::WAVE_1ST,
 248     _("視界内の全ての敵に%sによるダメージを与える。", "Inflict %s damage on all monsters in sight.") },
 249     { ElementSpells::BALL_2ND,
 250     _("%sの球を放つ。",  "Fire a ball of %s.") },
 251     { ElementSpells::BURST_1ST,
 252     _("ランダムな方向に%sの矢を放つ。", "Fire some bolts of %s in random direction.") },
 253     { ElementSpells::STORM_2ND,
 254     _("%sの巨大な球を放つ。", "Fire a large ball of %s.") },
 255     { ElementSpells::BREATH_1ST,
 256     _("%sのブレスを吐く。", "Fire a breath of %s.") },
 257     { ElementSpells::STORM_3ND,
 258     _("%sの巨大な球を放つ。", "Fire a large ball of %s.") },
 259 };
 260
 261 /*!
 262  * @brief 元素魔法選択時説明文定義
 263  */
 264 static element_text_list element_texts = {
 265     { ElementRealmType::FIRE,
 266     _("炎系統は巨大なエネルギーで灼熱を生み出し、全ての敵を燃やし尽くそうとします。",
 267         "Great energy of Fire system will be able to burn out all of your enemies.")},
 268     { ElementRealmType::ICE,
 269     _("氷系統の魔法はその冷たさで敵の動きを奪い尽くし、魂すらも止めてしまうでしょう。",
 270         "Ice system will freeze your enemies, even their souls.")},
 271     { ElementRealmType::SKY,
 272     _("空系統は大いなる天空のエネルギーを駆使して敵の全てを撃滅できます。",
 273         "Sky system can terminate all of your enemies powerfully with the energy of the great sky.")},
 274     { ElementRealmType::SEA,
 275     _("海系統はその敵の全てを溶かし、大いなる海へと返してしまいます。",
 276         "Sea system melts all of your enemies and returns them to the great ocean.")},
 277     { ElementRealmType::DARKNESS,
 278     _("闇系統は恐るべき力を常闇から引き出し、敵を地獄へと叩き落とすでしょう。",
 279         "Dark system draws terrifying power from the darkness and knocks your enemies into hell.")},
 280     { ElementRealmType::CHAOS,
 281     _("混沌系統は敵の意識も条理も捻じ曲げ、その存在をあの世に送ってしまいます。",
 282         "Chaos system twists and wraps your enemies, even their souls, and scatters them as dust in the wind.")},
 283     { ElementRealmType::EARTH,
 284     _("地系統は偉大なる大地の力を呼び出して、数多の敵のことごとくを粉砕しようとします。",
 285         "Earth system smashes all of your enemies massively using its huge powers.")},
 286     { ElementRealmType::DEATH,
 287     _("瘴気系統は全ての生ける者にとって途轍もない毒です。",
 288         "Death system is a tremendous poison for all living enemies.")},
 289 };
 290
 291 // clang-format on
 292
 293 /*!
 294  * @brief 元素魔法の領域名を返す
 295  * @param realm_idx 領域番号
 296  * @return 領域名
 297  */
 298 concptr get_element_title(int realm_idx)
 299 {
 300     auto realm = i2enum<ElementRealmType>(realm_idx);
 301     return element_types.at(realm).title.data();
 302 }
 303
 304 /*!
 305  * @brief 元素魔法領域の属性リストを返す
 306  * @param realm_idx 領域番号
 307  * @return 領域で使用できる属性リスト
 308  */
 309 static std::array<AttributeType, 3> get_element_types(int realm_idx)
 310 {
 311     auto realm = i2enum<ElementRealmType>(realm_idx);
 312     return element_types.at(realm).type;
 313 }
 314
 315 /*!
 316  * @brief 元素魔法領域のn番目の属性を返す
 317  * @param realm_idx 領域番号
 318  * @param n 属性の何番目か
 319  * @return 属性タイプ
 320  */
 321 AttributeType get_element_type(int realm_idx, int n)
 322 {
 323     return get_element_types(realm_idx)[n];
 324 }
 325
 326 /*!
 327  * @brief 元素魔法領域のn番目の呪文用の属性を返す
 328  * @param realm_idx 領域番号
 329  * @param n 属性の何番目か
 330  * @return 属性タイプ
 331  */
 332 static AttributeType get_element_spells_type(player_type *player_ptr, int n)
 333 {
 334     auto realm = element_types.at(i2enum<ElementRealmType>(player_ptr->element));
 335     auto t = realm.type.at(n);
 336     if (realm.extra.find(t) != realm.extra.end()) {
 337         if (randint0(100) < player_ptr->lev * 2)
 338             return realm.extra.at(t);
 339     }
 340     return t;
 341 }
 342
 343 /*!
 344  * @brief 元素魔法領域の属性名リストを返す
 345  * @param realm_idx 領域番号
 346  * @return 領域で使用できる属性の名称リスト
 347  */
 348 static std::array<std::string_view, 3> get_element_names(int realm_idx)
 349 {
 350     auto realm = i2enum<ElementRealmType>(realm_idx);
 351     return element_types.at(realm).name;
 352 }
 353
 354 /*!
 355  * @brief 元素魔法領域のn番目の属性名を返す
 356  * @param realm_idx 領域番号
 357  * @param n 属性の何番目か
 358  * @return 属性名
 359  */
 360 concptr get_element_name(int realm_idx, int n)
 361 {
 362     return get_element_names(realm_idx)[n].data();
 363 }
 364
 365 /*!
 366  * @brief 元素魔法の説明文を取得
 367  * @param player_ptr プレイヤー情報への参照ポインタ
 368  * @param spell_idx 呪文番号
 369  * @return 説明文
 370  */
 371 static concptr get_element_tip(player_type *player_ptr, int spell_idx)
 372 {
 373     auto realm = i2enum<ElementRealmType>(player_ptr->element);
 374     auto spell = i2enum<ElementSpells>(spell_idx);
 375     auto elem = element_powers.at(spell).elem;
 376     return format(element_tips.at(spell).data(), element_types.at(realm).name[elem].data());
 377 }
 378
 379 /*!
 380  * @brief 元素魔法の説明文を取得
 381  * @param player_ptr プレイヤー情報への参照ポインタ
 382  * @param spell_idx 呪文番号
 383  * @return 説明文
 384  */
 385 static int get_elemental_elem(player_type *player_ptr, int spell_idx)
 386 {
 387     (void)player_ptr;
 388     auto spell = i2enum<ElementSpells>(spell_idx);
 389     return element_powers.at(spell).elem;
 390 }
 391
 392 /*!
 393  * @brief 元素魔法呪文の難易度データを取得
 394  * @param player_ptr プレイヤー情報への参照ポインタ
 395  * @param spell_idx 呪文番号
 396  * @return 説明文
 397  */
 398 static mind_type get_elemental_info(player_type *player_ptr, int spell_idx)
 399 {
 400     (void)player_ptr;
 401     auto spell = i2enum<ElementSpells>(spell_idx);
 402     return element_powers.at(spell).info;
 403 }
 404
 405 /*!
 406  * @brief 元素魔法呪文の効果表示文字列を取得
 407  * @param player_ptr プレイヤー情報への参照ポインタ
 408  * @param spell_idx 呪文番号
 409  * @param p バッファ
 410  * @return なし(pを更新)
 411  */
 412 void get_element_effect_info(player_type *player_ptr, int spell_idx, char *p)
 413 {
 414     PLAYER_LEVEL plev = player_ptr->lev;
 415     auto spell = i2enum<ElementSpells>(spell_idx);
 416     int dam = 0;
 417
 418     switch (spell) {
 419     case ElementSpells::BOLT_1ST:
 420         sprintf(p, " %s%dd%d", KWD_DAM, 3 + ((plev - 1) / 5), 4);
 421         break;
 422     case ElementSpells::CURE:
 423         sprintf(p, " %s%dd%d", KWD_HEAL, 2, 8);
 424         break;
 425     case ElementSpells::BOLT_2ND:
 426         sprintf(p, " %s%dd%d", KWD_DAM, 8 + ((plev - 5) / 4), 8);
 427         break;
 428     case ElementSpells::BALL_3RD:
 429         sprintf(p, " %s%d", KWD_DAM, (50 + plev * 2));
 430         break;
 431     case ElementSpells::BALL_1ST:
 432         sprintf(p, " %s%d", KWD_DAM, 55 + plev);
 433         break;
 434     case ElementSpells::BREATH_2ND:
 435         dam = p_ptr->chp / 2;
 436         sprintf(p, " %s%d", KWD_DAM, (dam > 150) ? 150 : dam);
 437         break;
 438     case ElementSpells::ANNIHILATE:
 439         sprintf(p, " %s%d", _("効力:", "pow "), 50 + plev);
 440         break;
 441     case ElementSpells::BOLT_3RD:
 442         sprintf(p, " %s%dd%d", KWD_DAM, 12 + ((plev - 5) / 4), 8);
 443         break;
 444     case ElementSpells::WAVE_1ST:
 445         sprintf(p, " %s50+d%d", KWD_DAM, plev * 3);
 446         break;
 447     case ElementSpells::BALL_2ND:
 448         sprintf(p, " %s%d", KWD_DAM, 75 + plev * 3 / 2);
 449         break;
 450     case ElementSpells::BURST_1ST:
 451         sprintf(p, " %s%dd%d", KWD_DAM, 6 + plev / 8, 7);
 452         break;
 453     case ElementSpells::STORM_2ND:
 454         sprintf(p, " %s%d", KWD_DAM, 115 + plev * 5 / 2);
 455         break;
 456     case ElementSpells::BREATH_1ST:
 457         sprintf(p, " %s%d", KWD_DAM, p_ptr->chp * 2 / 3);
 458         break;
 459     case ElementSpells::STORM_3ND:
 460         sprintf(p, " %s%d", KWD_DAM, 300 + plev * 5);
 461         break;
 462     default:
 463         p[0] = '\0';
 464         break;
 465     }
 466 }
 467
 468 /*!
 469  * @brief 元素魔法呪文を実行する
 470  * @param player_ptr プレイヤー情報への参照ポインタ
 471  * @param spell_idx 呪文番号
 472  * @return 実行したらTRUE、キャンセルならFALSE
 473  */
 474 static bool cast_element_spell(player_type *player_ptr, SPELL_IDX spell_idx)
 475 {
 476     auto spell = i2enum<ElementSpells>(spell_idx);
 477     auto power = element_powers.at(spell);
 478     AttributeType typ;
 479     DIRECTION dir;
 480     PLAYER_LEVEL plev = player_ptr->lev;
 481     HIT_POINT dam;
 482     POSITION y, x;
 483     int num;
 484
 485     switch (spell) {
 486     case ElementSpells::BOLT_1ST:
 487         if (!get_aim_dir(player_ptr, &dir))
 488             return false;
 489         dam = damroll(3 + ((plev - 1) / 5), 4);
 490         typ = get_element_spells_type(player_ptr, power.elem);
 491         (void)fire_bolt(player_ptr, typ, dir, dam);
 492         break;
 493     case ElementSpells::MON_DETECT:
 494         (void)detect_monsters_normal(player_ptr, DETECT_RAD_DEFAULT);
 495         (void)detect_monsters_invis(player_ptr, DETECT_RAD_DEFAULT);
 496         break;
 497     case ElementSpells::PERCEPT:
 498         return psychometry(player_ptr);
 499     case ElementSpells::CURE:
 500         (void)hp_player(player_ptr, damroll(2, 8));
 501         (void)BadStatusSetter(player_ptr).mod_cut(-10);
 502         break;
 503     case ElementSpells::BOLT_2ND:
 504         if (!get_aim_dir(player_ptr, &dir))
 505             return false;
 506         dam = damroll(8 + ((plev - 5) / 4), 8);
 507         typ = get_element_spells_type(player_ptr, power.elem);
 508         if (fire_bolt_or_beam(player_ptr, plev, typ, dir, dam)) {
 509             if (typ == AttributeType::HYPODYNAMIA) {
 510                 (void)hp_player(player_ptr, dam / 2);
 511             }
 512         }
 513         break;
 514     case ElementSpells::MAG_DETECT:
 515         (void)detect_objects_magic(player_ptr, DETECT_RAD_DEFAULT);
 516         break;
 517     case ElementSpells::BALL_3RD:
 518         project_length = 4;
 519         if (!get_aim_dir(player_ptr, &dir))
 520             return false;
 521         typ = get_element_spells_type(player_ptr, power.elem);
 522         dam = 50 + plev * 2;
 523         (void)fire_ball(player_ptr, typ, dir, dam, 1);
 524         project_length = 0;
 525         break;
 526     case ElementSpells::BALL_1ST:
 527         if (!get_aim_dir(player_ptr, &dir))
 528             return false;
 529         dam = 55 + plev;
 530         typ = get_element_spells_type(player_ptr, power.elem);
 531         (void)fire_ball(player_ptr, typ, dir, dam, 2);
 532         break;
 533     case ElementSpells::BREATH_2ND:
 534         if (!get_aim_dir(player_ptr, &dir))
 535             return false;
 536         dam = std::min(150, player_ptr->chp / 2);
 537         typ = get_element_spells_type(player_ptr, power.elem);
 538         if (fire_breath(player_ptr, typ, dir, dam, 3)) {
 539             if (typ == AttributeType::HYPODYNAMIA) {
 540                 (void)hp_player(player_ptr, dam / 2);
 541             }
 542         }
 543         break;
 544     case ElementSpells::ANNIHILATE:
 545         if (!get_aim_dir(player_ptr, &dir))
 546             return false;
 547         fire_ball_hide(player_ptr, AttributeType::E_GENOCIDE, dir, plev + 50, 0);
 548         break;
 549     case ElementSpells::BOLT_3RD:
 550         if (!get_aim_dir(player_ptr, &dir))
 551             return false;
 552         dam = damroll(12 + ((plev - 5) / 4), 8);
 553         typ = get_element_spells_type(player_ptr, power.elem);
 554         fire_bolt_or_beam(player_ptr, plev, typ, dir, dam);
 555         break;
 556     case ElementSpells::WAVE_1ST:
 557         dam = 50 + randint1(plev * 3);
 558         typ = get_element_spells_type(player_ptr, power.elem);
 559         project_all_los(player_ptr, typ, dam);
 560         break;
 561     case ElementSpells::BALL_2ND:
 562         if (!get_aim_dir(player_ptr, &dir))
 563             return false;
 564         dam = 75 + plev * 3 / 2;
 565         typ = get_element_spells_type(player_ptr, power.elem);
 566         if (fire_ball(player_ptr, typ, dir, dam, 3)) {
 567             if (typ == AttributeType::HYPODYNAMIA) {
 568                 (void)hp_player(player_ptr, dam / 2);
 569             }
 570         }
 571         break;
 572     case ElementSpells::BURST_1ST:
 573         y = player_ptr->y;
 574         x = player_ptr->x;
 575         num = damroll(4, 3);
 576         typ = get_element_spells_type(player_ptr, power.elem);
 577         for (int k = 0; k < num; k++) {
 578             int attempts = 1000;
 579             while (attempts--) {
 580                 scatter(player_ptr, &y, &x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);
 581                 if (!cave_has_flag_bold(player_ptr->current_floor_ptr, y, x, FloorFeatureType::PROJECT))
 582                     continue;
 583                 if (!player_bold(player_ptr, y, x))
 584                     break;
 585             }
 586             project(player_ptr, 0, 0, y, x, damroll(6 + plev / 8, 7), typ, (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_KILL));
 587         }
 588         break;
 589     case ElementSpells::STORM_2ND:
 590         if (!get_aim_dir(player_ptr, &dir))
 591             return false;
 592         dam = 115 + plev * 5 / 2;
 593         typ = get_element_spells_type(player_ptr, power.elem);
 594         if (fire_ball(player_ptr, typ, dir, dam, 4)) {
 595             if (typ == AttributeType::HYPODYNAMIA) {
 596                 (void)hp_player(player_ptr, dam / 2);
 597             }
 598         }
 599         break;
 600     case ElementSpells::BREATH_1ST:
 601         if (!get_aim_dir(player_ptr, &dir))
 602             return false;
 603         dam = player_ptr->chp * 2 / 3;
 604         typ = get_element_spells_type(player_ptr, power.elem);
 605         (void)fire_breath(player_ptr, typ, dir, dam, 3);
 606         break;
 607     case ElementSpells::STORM_3ND:
 608         if (!get_aim_dir(player_ptr, &dir))
 609             return false;
 610         dam = 300 + plev * 5;
 611         typ = get_element_spells_type(player_ptr, power.elem);
 612         (void)fire_ball(player_ptr, typ, dir, dam, 5);
 613         break;
 614     default:
 615         return false;
 616     }
 617
 618     return true;
 619 }
 620
 621 /*!
 622  * @brief 元素魔法呪文の失敗率を計算
 623  * @param player_ptr プレイヤー情報への参照ポインタ
 624  * @param spell_idx 呪文番号
 625  * @return 失敗率
 626  */
 627 static PERCENTAGE decide_element_chance(player_type *player_ptr, mind_type spell)
 628 {
 629     PERCENTAGE chance = spell.fail;
 630
 631     chance -= 3 * (player_ptr->lev - spell.min_lev);
 632     chance += player_ptr->to_m_chance;
 633     chance -= 3 * (adj_mag_stat[player_ptr->stat_index[A_WIS]] - 1);
 634
 635     PERCENTAGE minfail = adj_mag_fail[player_ptr->stat_index[A_WIS]];
 636     if (chance < minfail)
 637         chance = minfail;
 638
 639     auto player_stun = player_ptr->effects()->stun();
 640     chance += player_stun->get_magic_chance_penalty();
 641     if (heavy_armor(player_ptr))
 642         chance += 5;
 643
 644     if (player_ptr->is_icky_wield[0])
 645         chance += 5;
 646
 647     if (player_ptr->is_icky_wield[1])
 648         chance += 5;
 649
 650     if (chance > 95)
 651         chance = 95;
 652
 653     return chance;
 654 }
 655
 656 /*!
 657  * @brief 元素魔法呪文の消費MPを計算
 658  * @param player_ptr プレイヤー情報への参照ポインタ
 659  * @param spell_idx 呪文番号
 660  * @return 消費MP
 661  */
 662 static MANA_POINT decide_element_mana_cost(player_type *player_ptr, mind_type spell)
 663 {
 664     (void)player_ptr;
 665     return spell.mana_cost;
 666 }
 667
 668 /*!
 669  * @brief 元素魔法呪文を選択して取得
 670  * @param player_ptr プレイヤー情報への参照ポインタ
 671  * @param sn 呪文番号
 672  * @param only_browse 閲覧モードかどうか
 673  * @return 選んだらTRUE、選ばなかったらFALSE
 674  */
 675 bool get_element_power(player_type *player_ptr, SPELL_IDX *sn, bool only_browse)
 676 {
 677     SPELL_IDX i;
 678     int num = 0;
 679     TERM_LEN y = 1;
 680     TERM_LEN x = 10;
 681     PLAYER_LEVEL plev = player_ptr->lev;
 682     int ask = true;
 683     char choice;
 684     char out_val[160];
 685     char comment[80];
 686     COMMAND_CODE code;
 687     bool flag, redraw;
 688     int menu_line = (use_menu ? 1 : 0);
 689
 690     *sn = -1;
 691     if (repeat_pull(&code)) {
 692         *sn = (SPELL_IDX)code;
 693         if (get_elemental_info(player_ptr, *sn).min_lev <= plev)
 694             return true;
 695     }
 696
 697     concptr p = _("元素魔法", "magic");
 698     flag = false;
 699     redraw = false;
 700
 701     for (i = 0; i < static_cast<SPELL_IDX>(ElementSpells::MAX); i++) {
 702         if (get_elemental_info(player_ptr, i).min_lev <= plev)
 703             num++;
 704     }
 705
 706     if (only_browse)
 707         (void)strnfmt(out_val, 78, _("(%^s %c-%c, '*'で一覧, ESC) どの%sについて知りますか？", "(%^ss %c-%c, *=List, ESC=exit) Use which %s? "), p, I2A(0),
 708             I2A(num - 1), p);
 709     else
 710         (void)strnfmt(
 711             out_val, 78, _("(%^s %c-%c, '*'で一覧, ESC) どの%sを使いますか？", "(%^ss %c-%c, *=List, ESC=exit) Use which %s? "), p, I2A(0), I2A(num - 1), p);
 712
 713     if (use_menu && !only_browse)
 714         screen_save();
 715
 716     int elem;
 717     mind_type spell;
 718     choice = (always_show_list || use_menu) ? ESCAPE : 1;
 719     while (!flag) {
 720         if (choice == ESCAPE)
 721             choice = ' ';
 722         else if (!get_com(out_val, &choice, true))
 723             break;
 724
 725         if (use_menu && choice != ' ') {
 726             switch (choice) {
 727             case '0':
 728                 if (!only_browse)
 729                     screen_load();
 730                 return false;
 731             case '8':
 732             case 'k':
 733             case 'K':
 734                 menu_line += (num - 1);
 735                 break;
 736             case '2':
 737             case 'j':
 738             case 'J':
 739                 menu_line++;
 740                 break;
 741             case 'x':
 742             case 'X':
 743             case '\r':
 744             case '\n':
 745                 i = menu_line - 1;
 746                 ask = false;
 747                 break;
 748             }
 749
 750             if (menu_line > num)
 751                 menu_line -= num;
 752         }
 753
 754         int spell_max = enum2i(ElementSpells::MAX);
 755         if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask)) {
 756             if (!redraw || use_menu) {
 757                 char desc[80];
 758                 char name[80];
 759                 redraw = true;
 760                 if (!only_browse && !use_menu)
 761                     screen_save();
 762
 763                 prt("", y, x);
 764                 put_str(_("名前", "Name"), y, x + 5);
 765                 put_str(_("Lv   MP   失率 効果", "Lv   MP   Fail Info"), y, x + 35);
 766                 for (i = 0; i < spell_max; i++) {
 767                     elem = get_elemental_elem(player_ptr, i);
 768                     spell = get_elemental_info(player_ptr, i);
 769
 770                     if (spell.min_lev > plev)
 771                         break;
 772
 773                     PERCENTAGE chance = decide_element_chance(player_ptr, spell);
 774                     int mana_cost = decide_element_mana_cost(player_ptr, spell);
 775                     get_element_effect_info(player_ptr, i, comment);
 776
 777                     if (use_menu) {
 778                         if (i == (menu_line - 1))
 779                             strcpy(desc, _("  》 ", "  >  "));
 780                         else
 781                             strcpy(desc, "     ");
 782                     } else
 783                         sprintf(desc, "  %c) ", I2A(i));
 784
 785                     concptr s = get_element_name(player_ptr->element, elem);
 786                     sprintf(name, spell.name, s);
 787                     strcat(desc, format("%-30s%2d %4d %3d%%%s", name, spell.min_lev, mana_cost, chance, comment));
 788                     prt(desc, y + i + 1, x);
 789                 }
 790
 791                 prt("", y + i + 1, x);
 792             } else if (!only_browse) {
 793                 redraw = false;
 794                 screen_load();
 795             }
 796
 797             continue;
 798         }
 799
 800         if (!use_menu) {
 801             ask = isupper(choice);
 802             if (ask)
 803                 choice = (char)tolower(choice);
 804
 805             i = (islower(choice) ? A2I(choice) : -1);
 806         }
 807
 808         if ((i < 0) || (i >= num)) {
 809             bell();
 810             continue;
 811         }
 812
 813         if (ask) {
 814             char name[80];
 815             char tmp_val[160];
 816             elem = get_elemental_elem(player_ptr, i);
 817             spell = get_elemental_info(player_ptr, i);
 818             (void)sprintf(name, spell.name, get_element_name(player_ptr->element, elem));
 819             (void)strnfmt(tmp_val, 78, _("%sを使いますか？", "Use %s? "), name);
 820             if (!get_check(tmp_val))
 821                 continue;
 822         }
 823
 824         flag = true;
 825     }
 826
 827     if (redraw && !only_browse)
 828         screen_load();
 829
 830     set_bits(player_ptr->window_flags, PW_SPELL);
 831     handle_stuff(player_ptr);
 832     if (!flag)
 833         return false;
 834
 835     *sn = i;
 836     repeat_push((COMMAND_CODE)i);
 837     return true;
 838 }
 839
 840 /*!
 841  * @brief 元素魔法呪文をMPがなくても挑戦するか確認する
 842  * @param player_ptr プレイヤー情報への参照ポインタ
 843  * @param mana_cost 消費MP
 844  * @return 詠唱するならTRUE、しないならFALSE
 845  */
 846 static bool check_element_mp_sufficiency(player_type *player_ptr, int mana_cost)
 847 {
 848     if (mana_cost <= player_ptr->csp)
 849         return true;
 850
 851     msg_print(_("ＭＰが足りません。", "You do not have enough mana to use this power."));
 852     if (!over_exert)
 853         return false;
 854
 855     return get_check(_("それでも挑戦しますか? ", "Attempt it anyway? "));
 856 }
 857
 858 /*!
 859  * @brief 元素魔法呪文の詠唱を試み、成功なら詠唱し、失敗ならファンブルする
 860  * @param player_ptr プレイヤー情報への参照ポインタ
 861  * @param spell_idx 呪文番号
 862  * @param chance 失敗率
 863  * @return 詠唱して実行したらTRUE、されなかったらFALSE
 864  */
 865 static bool try_cast_element_spell(player_type *player_ptr, SPELL_IDX spell_idx, PERCENTAGE chance)
 866 {
 867     if (randint0(100) >= chance) {
 868         sound(SOUND_ZAP);
 869         return cast_element_spell(player_ptr, spell_idx);
 870     }
 871
 872     if (flush_failure)
 873         flush();
 874
 875     msg_format(_("魔力の集中に失敗した！", "You failed to concentrate hard enough for Mana!"));
 876     sound(SOUND_FAIL);
 877
 878     if (randint1(100) < chance / 2) {
 879         int plev = player_ptr->lev;
 880         msg_print(_("元素の力が制御できない氾流となって解放された！", "Elemental power unleashes its power in an uncontrollable storm!"));
 881         project(player_ptr, PROJECT_WHO_UNCTRL_POWER, 2 + plev / 10, player_ptr->y, player_ptr->x, plev * 2, get_element_types(player_ptr->element)[0],
 882             PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM);
 883         player_ptr->csp = std::max(0, player_ptr->csp - player_ptr->msp * 10 / (20 + randint1(10)));
 884
 885         PlayerEnergy(player_ptr).set_player_turn_energy(100);
 886         set_bits(player_ptr->redraw, PR_MANA);
 887         set_bits(player_ptr->window_flags, PW_PLAYER | PW_SPELL);
 888
 889         return false;
 890     }
 891
 892     return true;
 893 }
 894
 895 /*!
 896  * @brief 元素魔法コマンドのメインルーチン
 897  * @param player_ptr プレイヤー情報への参照ポインタ
 898  */
 899 void do_cmd_element(player_type *player_ptr)
 900 {
 901     SPELL_IDX i;
 902     if (cmd_limit_confused(player_ptr) || !get_element_power(player_ptr, &i, false))
 903         return;
 904
 905     mind_type spell = get_elemental_info(player_ptr, i);
 906     PERCENTAGE chance = decide_element_chance(player_ptr, spell);
 907     int mana_cost = decide_element_mana_cost(player_ptr, spell);
 908
 909     if (!check_element_mp_sufficiency(player_ptr, mana_cost))
 910         return;
 911
 912     if (!try_cast_element_spell(player_ptr, i, chance))
 913         return;
 914
 915     if (mana_cost <= player_ptr->csp) {
 916         player_ptr->csp -= mana_cost;
 917     } else {
 918         int oops = mana_cost;
 919         player_ptr->csp = 0;
 920         player_ptr->csp_frac = 0;
 921         msg_print(_("精神を集中しすぎて気を失ってしまった！", "You faint from the effort!"));
 922         (void)BadStatusSetter(player_ptr).mod_paralysis(randint1(5 * oops + 1));
 923         chg_virtue(player_ptr, V_KNOWLEDGE, -10);
 924         if (randint0(100) < 50) {
 925             bool perm = (randint0(100) < 25);
 926             msg_print(_("体を悪くしてしまった！", "You have damaged your health!"));
 927             (void)dec_stat(player_ptr, A_CON, 15 + randint1(10), perm);
 928         }
 929     }
 930
 931     PlayerEnergy(player_ptr).set_player_turn_energy(100);
 932     set_bits(player_ptr->redraw, PR_MANA);
 933     set_bits(player_ptr->window_flags, PW_PLAYER | PW_SPELL);
 934 }
 935
 936 /*!
 937  * @brief 現在プレイヤーが使用可能な元素魔法の一覧表示
 938  * @param player_ptr プレイヤー情報への参照ポインタ
 939  */
 940 void do_cmd_element_browse(player_type *player_ptr)
 941 {
 942     SPELL_IDX n = 0;
 943     char temp[62 * 5];
 944
 945     screen_save();
 946     while (true) {
 947         if (!get_element_power(player_ptr, &n, true)) {
 948             screen_load();
 949             return;
 950         }
 951
 952         term_erase(12, 21, 255);
 953         term_erase(12, 20, 255);
 954         term_erase(12, 19, 255);
 955         term_erase(12, 18, 255);
 956         term_erase(12, 17, 255);
 957         term_erase(12, 16, 255);
 958         shape_buffer(get_element_tip(player_ptr, n), 62, temp, sizeof(temp));
 959         for (int j = 0, line = 17; temp[j]; j += (1 + strlen(&temp[j]))) {
 960             prt(&temp[j], line, 15);
 961             line++;
 962         }
 963
 964         prt(_("何かキーを押して下さい。", "Hit any key."), 0, 0);
 965         (void)inkey();
 966     }
 967 }
 968
 969 /*!
 970  * @brief 元素魔法の単体抹殺が有効か確認する
 971  * @param r_ptr モンスター種族への参照ポインタ
 972  * @param type 魔法攻撃属性
 973  * @return 効果があるならTRUE、なければFALSE
 974  */
 975 bool is_elemental_genocide_effective(monster_race *r_ptr, AttributeType type)
 976 {
 977     switch (type) {
 978     case AttributeType::FIRE:
 979         if (any_bits(r_ptr->flagsr, RFR_IM_FIRE))
 980             return false;
 981         break;
 982     case AttributeType::COLD:
 983         if (any_bits(r_ptr->flagsr, RFR_IM_COLD))
 984             return false;
 985         break;
 986     case AttributeType::ELEC:
 987         if (any_bits(r_ptr->flagsr, RFR_IM_ELEC))
 988             return false;
 989         break;
 990     case AttributeType::ACID:
 991         if (any_bits(r_ptr->flagsr, RFR_IM_ACID))
 992             return false;
 993         break;
 994     case AttributeType::DARK:
 995         if (any_bits(r_ptr->flagsr, RFR_RES_DARK) || any_bits(r_ptr->r_flags3, RF3_HURT_LITE))
 996             return false;
 997         break;
 998     case AttributeType::CONFUSION:
 999         if (any_bits(r_ptr->flags3, RF3_NO_CONF))
1000             return false;
1001         break;
1002     case AttributeType::SHARDS:
1003         if (any_bits(r_ptr->flagsr, RFR_RES_SHAR))
1004             return false;
1005         break;
1006     case AttributeType::POIS:
1007         if (any_bits(r_ptr->flagsr, RFR_IM_POIS))
1008             return false;
1009         break;
1010     default:
1011         return false;
1012     }
1013
1014     return true;
1015 }
1016
1017 /*!
1018  * @brief 元素魔法の単体抹殺の効果を発動する
1019  * @param player_ptr プレイヤー情報への参照ポインタ
1020  * @param em_ptr 魔法効果情報への参照ポインタ
1021  * @return 効果処理を続けるかどうか
1022  */
1023 process_result effect_monster_elemental_genocide(player_type *player_ptr, effect_monster_type *em_ptr)
1024 {
1025     auto type = get_element_type(player_ptr->element, 0);
1026     auto name = get_element_name(player_ptr->element, 0);
1027     bool b = is_elemental_genocide_effective(em_ptr->r_ptr, type);
1028
1029     if (em_ptr->seen_msg)
1030         msg_format(_("%sが%sを包み込んだ。", "The %s surrounds %s."), name, em_ptr->m_name);
1031
1032     if (em_ptr->seen)
1033         em_ptr->obvious = true;
1034
1035     if (!b) {
1036         if (em_ptr->seen_msg)
1037             msg_format(_("%sには効果がなかった。", "%^s is unaffected."), em_ptr->m_name);
1038         em_ptr->dam = 0;
1039         return PROCESS_TRUE;
1040     }
1041
1042     if (genocide_aux(player_ptr, em_ptr->g_ptr->m_idx, em_ptr->dam, !em_ptr->who, (em_ptr->r_ptr->level + 1) / 2, _("モンスター消滅", "Genocide One"))) {
1043         if (em_ptr->seen_msg)
1044             msg_format(_("%sは消滅した！", "%^s disappeared!"), em_ptr->m_name);
1045         em_ptr->dam = 0;
1046         chg_virtue(player_ptr, V_VITALITY, -1);
1047         return PROCESS_TRUE;
1048     }
1049
1050     em_ptr->skipped = true;
1051     return PROCESS_CONTINUE;
1052 }
1053
1054 /*!
1055  * @brief 元素領域とレベルの条件に見合うかチェックする
1056  * @param player_ptr プレイヤー情報への参照ポインタ
1057  * @param realm 領域
1058  * @param lev プレイヤーレベル
1059  * @return 見合うならTRUE、そうでなければFALSE
1060  * @details
1061  * レベルに応じて取得する耐性などの判定に使用する
1062  */
1063 bool has_element_resist(player_type *player_ptr, ElementRealmType realm, PLAYER_LEVEL lev)
1064 {
1065     if (player_ptr->pclass != PlayerClassType::ELEMENTALIST)
1066         return false;
1067
1068     auto prealm = i2enum<ElementRealmType>(player_ptr->element);
1069     return (prealm == realm && player_ptr->lev >= lev);
1070 }
1071
1072 /*!
1073  * @brief 領域選択時のカーソル表示(シンボル＋領域名)
1074  * @param i 位置
1075  * @param n 最後尾の位置
1076  * @param color 表示色
1077  */
1078 static void display_realm_cursor(int i, int n, term_color_type color)
1079 {
1080     char cur[80];
1081     char sym;
1082     concptr name;
1083     if (i == n) {
1084         sym = '*';
1085         name = _("ランダム", "Random");
1086     } else {
1087         sym = I2A(i);
1088         name = element_types.at(i2enum<ElementRealmType>(i + 1)).title.data();
1089     }
1090     sprintf(cur, "%c) %s", sym, name);
1091
1092     c_put_str(color, cur, 12 + (i / 5), 2 + 15 * (i % 5));
1093 }
1094
1095 /*!
1096  * @brief 領域選択時の移動キー処理
1097  * @param cs 現在位置
1098  * @param n 最後尾の位置
1099  * @param c 入力キー
1100  * @return 新しい位置
1101  */
1102 static int interpret_realm_select_key(int cs, int n, char c)
1103 {
1104     if (c == 'Q')
1105         quit(nullptr);
1106
1107     if (c == '8')
1108         if (cs >= 5)
1109             return cs - 5;
1110
1111     if (c == '4')
1112         if (cs > 0)
1113             return cs - 1;
1114
1115     if (c == '6')
1116         if (cs < n)
1117             return cs + 1;
1118
1119     if (c == '2')
1120         if (cs + 5 <= n)
1121             return cs + 5;
1122
1123     return cs;
1124 }
1125
1126 /*!
1127  * @brief 領域選択ループ処理
1128  * @param player_ptr プレイヤー情報への参照ポインタ
1129  * @param n 最後尾の位置
1130  * @return 領域番号
1131  */
1132 static int get_element_realm(player_type *player_ptr, int is, int n)
1133 {
1134     int cs = std::max(0, is);
1135     int os = cs;
1136     int k;
1137
1138     char buf[80];
1139     sprintf(buf, _("領域を選んで下さい(%c-%c) ('='初期オプション設定): ", "Choose a realm (%c-%c) ('=' for options): "), I2A(0), I2A(n - 1));
1140
1141     while (true) {
1142         display_realm_cursor(os, n, TERM_WHITE);
1143         display_realm_cursor(cs, n, TERM_YELLOW);
1144         put_str(buf, 10, 10);
1145         os = cs;
1146
1147         char c = inkey();
1148         cs = interpret_realm_select_key(cs, n, c);
1149
1150         if (c == 'S')
1151             return 255;
1152
1153         if (c == ' ' || c == '\r' || c == '\n') {
1154             if (cs == n) {
1155                 display_realm_cursor(cs, n, TERM_WHITE);
1156                 cs = randint0(n - 1);
1157             }
1158             break;
1159         }
1160
1161         if (c == '*') {
1162             display_realm_cursor(cs, n, TERM_WHITE);
1163             cs = randint0(n - 1);
1164             break;
1165         }
1166
1167         k = islower(c) ? A2I(c) : -1;
1168         if (k >= 0 && k < n) {
1169             display_realm_cursor(cs, n, TERM_WHITE);
1170             cs = k;
1171             break;
1172         }
1173
1174         k = isupper(c) ? (26 + c - 'A') : -1;
1175         if (k >= 26 && k < n) {
1176             display_realm_cursor(cs, n, TERM_WHITE);
1177             cs = k;
1178             break;
1179         }
1180
1181         if (c == '=') {
1182             screen_save();
1183             do_cmd_options_aux(player_ptr, OPT_PAGE_BIRTH, _("初期オプション((*)はスコアに影響)", "Birth Options ((*)) affect score"));
1184             screen_load();
1185         } else if (c != '2' && c != '4' && c != '6' && c != '8')
1186             bell();
1187     }
1188
1189     display_realm_cursor(cs, n, TERM_YELLOW);
1190     return (cs + 1);
1191 }
1192
1193 /*!
1194  * @brief 領域選択
1195  * @param player_ptr プレイヤー情報への参照ポインタ
1196  * @return 領域番号
1197  */
1198 byte select_element_realm(player_type *player_ptr)
1199 {
1200     clear_from(10);
1201
1202     int realm_max = enum2i(ElementRealmType::MAX);
1203     int realm_idx = 1;
1204     int row = 16;
1205     while (1) {
1206         put_str(
1207             _("注意：元素系統の選択によりあなたが習得する呪文のタイプが決まります。", "Note: The system of element will determine which spells you can learn."),
1208             23, 5);
1209
1210         for (int i = 0; i < realm_max; i++) {
1211             display_realm_cursor(i, realm_max - 1, TERM_WHITE);
1212         }
1213
1214         realm_idx = get_element_realm(player_ptr, realm_idx - 1, realm_max - 1);
1215         if (realm_idx == 255)
1216             break;
1217
1218         auto realm = i2enum<ElementRealmType>(realm_idx);
1219         char temp[80 * 5];
1220         shape_buffer(element_texts.at(realm).data(), 74, temp, sizeof(temp));
1221         concptr t = temp;
1222         for (int i = 0; i < 5; i++) {
1223             if (t[0] == 0)
1224                 break;
1225             prt(t, row + i, 3);
1226             t += strlen(t) + 1;
1227         }
1228
1229         if (get_check_strict(player_ptr, _("よろしいですか？", "Are you sure? "), CHECK_DEFAULT_Y))
1230             break;
1231
1232         clear_from(row);
1233     }
1234
1235     clear_from(10);
1236     return (byte)realm_idx;
1237 }
1238
1239 /*!
1240  * @brief クラスパワー情報を追加
1241  * @param player_ptr プレイヤー情報への参照ポインタ
1242  * @param rc_ptr レイシャルパワー情報への参照ポインタ
1243  */
1244 void switch_element_racial(player_type *player_ptr, rc_type *rc_ptr)
1245 {
1246     auto plev = player_ptr->lev;
1247     auto realm = i2enum<ElementRealmType>(player_ptr->element);
1248     rpi_type rpi;
1249     switch (realm) {
1250     case ElementRealmType::FIRE:
1251         rpi = rpi_type(_("ライト・エリア", "Light area"));
1252         rpi.text = _("光源が照らしている範囲か部屋全体を永久に明るくする。", "Lights up nearby area and the inside of a room permanently.");
1253         rpi.min_level = 3;
1254         rpi.cost = 5;
1255         rpi.stat = A_WIS;
1256         rpi.fail = 10;
1257         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1258         break;
1259     case ElementRealmType::ICE:
1260         rpi = rpi_type(_("周辺フリーズ", "Sleep monsters"));
1261         rpi.info = format("%s%d", KWD_POWER, 20 + plev * 3 / 2);
1262         rpi.text = _("視界内の全てのモンスターを眠らせる。抵抗されると無効。", "Attempts to put all monsters in sight to sleep.");
1263         rpi.min_level = 10;
1264         rpi.cost = 15;
1265         rpi.stat = A_WIS;
1266         rpi.fail = 25;
1267         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1268         break;
1269     case ElementRealmType::SKY:
1270         rpi = rpi_type(_("魔力充填", "Recharging"));
1271         rpi.info = format("%s%d", KWD_POWER, 120);
1272         rpi.text = _("杖/魔法棒の充填回数を増やすか、充填中のロッドの充填時間を減らす。", "Recharges staffs, wands or rods.");
1273         rpi.min_level = 20;
1274         rpi.cost = 15;
1275         rpi.stat = A_WIS;
1276         rpi.fail = 25;
1277         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1278         break;
1279     case ElementRealmType::SEA:
1280         rpi = rpi_type(_("岩石溶解", "Stone to mud"));
1281         rpi.text = _("壁を溶かして床にする。", "Turns one rock square to mud.");
1282         rpi.min_level = 5;
1283         rpi.cost = 5;
1284         rpi.stat = A_WIS;
1285         rpi.fail = 10;
1286         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1287         break;
1288     case ElementRealmType::DARKNESS:
1289         rpi = rpi_type(format(_("闇の扉", "Door to darkness"), 15 + plev / 2));
1290         rpi.info = format("%s%d", KWD_SPHERE, 15 + plev / 2);
1291         rpi.min_level = 5;
1292         rpi.cost = 5 + plev / 7;
1293         rpi.stat = A_WIS;
1294         rpi.fail = 20;
1295         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1296         break;
1297     case ElementRealmType::CHAOS:
1298         rpi = rpi_type(_("現実変容", "Alter reality"));
1299         rpi.text = _("現在の階を再構成する。", "Recreates current dungeon level.");
1300         rpi.min_level = 35;
1301         rpi.cost = 30;
1302         rpi.stat = A_WIS;
1303         rpi.fail = 40;
1304         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1305         break;
1306     case ElementRealmType::EARTH:
1307         rpi = rpi_type(_("地震", "Earthquake"));
1308         rpi.info = format("%s%d", KWD_SPHERE, 10);
1309         rpi.text = _("周囲のダンジョンを揺らし、壁と床をランダムに入れ変える。", "Shakes dungeon structure, and results in random swapping of floors and walls.");
1310         rpi.min_level = 25;
1311         rpi.cost = 15;
1312         rpi.stat = A_WIS;
1313         rpi.fail = 20;
1314         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1315         break;
1316     case ElementRealmType::DEATH:
1317         rpi = rpi_type(_("増殖阻止", "Sterilization"));
1318         rpi.text = _("この階の増殖するモンスターが増殖できなくなる。", "Prevents any breeders on current level from breeding.");
1319         rpi.min_level = 5;
1320         rpi.cost = 5;
1321         rpi.stat = A_WIS;
1322         rpi.fail = 20;
1323         rc_ptr->add_power(rpi, RC_IDX_CLASS_1);
1324         break;
1325     default:
1326         break;
1327     }
1328 }
1329
1330 /*!
1331  * @todo 宣言だけ。後日適切な場所に移動
1332  */
1333 static bool door_to_darkness(player_type *player_ptr, POSITION dist);
1334
1335 /*!
1336  * @brief クラスパワーを実行
1337  * @param player_ptr プレイヤー情報への参照ポインタ
1338  * @return 実行したらTRUE、しなかったらFALSE
1339  */
1340 bool switch_element_execution(player_type *player_ptr)
1341 {
1342     auto realm = i2enum<ElementRealmType>(player_ptr->element);
1343     PLAYER_LEVEL plev = player_ptr->lev;
1344     DIRECTION dir;
1345
1346     switch (realm) {
1347     case ElementRealmType::FIRE:
1348         (void)lite_area(player_ptr, damroll(2, plev / 2), plev / 10);
1349         break;
1350     case ElementRealmType::ICE:
1351         (void)project(player_ptr, 0, 5, player_ptr->y, player_ptr->x, 1, AttributeType::COLD, PROJECT_ITEM);
1352         (void)project_all_los(player_ptr, AttributeType::OLD_SLEEP, 20 + plev * 3 / 2);
1353         break;
1354     case ElementRealmType::SKY:
1355         (void)recharge(player_ptr, 120);
1356         break;
1357     case ElementRealmType::SEA:
1358         if (!get_aim_dir(player_ptr, &dir))
1359             return false;
1360         (void)wall_to_mud(player_ptr, dir, plev * 3 / 2);
1361         break;
1362     case ElementRealmType::DARKNESS:
1363         return door_to_darkness(player_ptr, 15 + plev / 2);
1364         break;
1365     case ElementRealmType::CHAOS:
1366         reserve_alter_reality(player_ptr, randint0(21) + 15);
1367         break;
1368     case ElementRealmType::EARTH:
1369         (void)earthquake(player_ptr, player_ptr->y, player_ptr->x, 10, 0);
1370         break;
1371     case ElementRealmType::DEATH:
1372         if (player_ptr->current_floor_ptr->num_repro <= MAX_REPRO)
1373             player_ptr->current_floor_ptr->num_repro += MAX_REPRO;
1374         break;
1375     default:
1376         return false;
1377     }
1378
1379     return true;
1380 }
1381
1382 /*!
1383  * @brief 指定したマスが暗いかどうか
1384  * @param f_ptr 階の情報への参照ポインタ
1385  * @param y 指定のy座標
1386  * @param x 指定のx座標
1387  * @return 暗いならTRUE、そうでないならFALSE
1388  */
1389 static bool is_target_grid_dark(floor_type *f_ptr, POSITION y, POSITION x)
1390 {
1391     if (any_bits(f_ptr->grid_array[y][x].info, CAVE_MNLT))
1392         return false;
1393
1394     bool is_dark = false;
1395     bool is_lite = any_bits(f_ptr->grid_array[y][x].info, CAVE_GLOW | CAVE_LITE);
1396
1397     for (int dx = x - 2; dx <= x + 2; dx++)
1398         for (int dy = y - 2; dy <= y + 2; dy++) {
1399             if (dx == x && dy == y)
1400                 continue;
1401             if (!in_bounds(f_ptr, dy, dx))
1402                 continue;
1403
1404             MONSTER_IDX m_idx = f_ptr->grid_array[dy][dx].m_idx;
1405             if (!m_idx)
1406                 continue;
1407
1408             POSITION d = distance(dy, dx, y, x);
1409             monster_race *r_ptr = &r_info[f_ptr->m_list[m_idx].r_idx];
1410             if (d <= 1 && any_bits(r_ptr->flags7, RF7_HAS_LITE_1 | RF7_SELF_LITE_1))
1411                 return false;
1412             if (d <= 2 && any_bits(r_ptr->flags7, RF7_HAS_LITE_2 | RF7_SELF_LITE_2))
1413                 return false;
1414             if (d <= 1 && any_bits(r_ptr->flags7, RF7_HAS_DARK_1 | RF7_SELF_DARK_1))
1415                 is_dark = true;
1416             if (d <= 2 && any_bits(r_ptr->flags7, RF7_HAS_DARK_2 | RF7_SELF_DARK_2))
1417                 is_dark = true;
1418         }
1419
1420     return !is_lite || is_dark;
1421 }
1422
1423 /*!
1424  * @breif 暗いところ限定での次元の扉
1425  * @param player_ptr プレイヤー情報への参照ポインタ
1426  */
1427 static bool door_to_darkness(player_type *player_ptr, POSITION dist)
1428 {
1429     POSITION y = player_ptr->y;
1430     POSITION x = player_ptr->x;
1431     floor_type *f_ptr;
1432
1433     for (int i = 0; i < 3; i++) {
1434         if (!tgt_pt(player_ptr, &x, &y))
1435             return false;
1436
1437         f_ptr = player_ptr->current_floor_ptr;
1438
1439         if (distance(y, x, player_ptr->y, player_ptr->x) > dist) {
1440             msg_print(_("遠すぎる！", "There is too far!"));
1441             continue;
1442         }
1443
1444         if (!is_cave_empty_bold(player_ptr, y, x) || f_ptr->grid_array[y][x].is_icky()) {
1445             msg_print(_("そこには移動できない。", "Can not teleport to there."));
1446             continue;
1447         }
1448
1449         break;
1450     }
1451
1452     bool flag = cave_player_teleportable_bold(player_ptr, y, x, TELEPORT_SPONTANEOUS) && is_target_grid_dark(f_ptr, y, x);
1453     if (flag) {
1454         teleport_player_to(player_ptr, y, x, TELEPORT_SPONTANEOUS);
1455     } else {
1456         msg_print(_("闇の扉は開かなかった！", "Door to darkness does not open!"));
1457     }
1458     return true;
1459 }