src/cmd-spell.c

   1 /*!
   2     @file cmd-spell.c
   3     @brief 魔法のインターフェイスと発動 / Purpose: Do everything for each spell
   4     @date 2013/12/31
   5     @author
   6     2013 Deskull rearranged comment for Doxygen.
   7  */
   8
   9 #include "angband.h"
  10 #include "util.h"
  11
  12 #include "selfinfo.h"
  13 #include "spells-summon.h"
  14 #include "realm-arcane.h"
  15 #include "realm-chaos.h"
  16 #include "realm-craft.h"
  17 #include "realm-crusade.h"
  18 #include "realm-daemon.h"
  19 #include "realm-death.h"
  20 #include "realm-hex.h"
  21 #include "realm-hissatsu.h"
  22 #include "realm-life.h"
  23 #include "realm-nature.h"
  24 #include "realm-song.h"
  25 #include "realm-sorcery.h"
  26 #include "realm-trump.h"
  27 #include "mind.h"
  28 #include "avatar.h"
  29 #include "player-status.h"
  30 #include "player-effects.h"
  31 #include "object-hook.h"
  32 #include "cmd-basic.h"
  33
  34 /*!
  35  * @brief
  36  * 魔法の効果を「キャプション:ダイス＋定数値」のフォーマットで出力する / Generate dice info string such as "foo 2d10"
  37  * @param str キャプション
  38  * @param dice ダイス数
  39  * @param sides ダイス目
  40  * @param base 固定値
  41  * @return フォーマットに従い整形された文字列
  42  */
  43 concptr info_string_dice(concptr str, DICE_NUMBER dice, DICE_SID sides, int base)
  44 {
  45         /* Fix value */
  46         if (!dice)
  47                 return format("%s%d", str, base);
  48
  49         /* Dice only */
  50         else if (!base)
  51                 return format("%s%dd%d", str, dice, sides);
  52
  53         /* Dice plus base value */
  54         else
  55                 return format("%s%dd%d%+d", str, dice, sides, base);
  56 }
  57
  58
  59 /*!
  60  * @brief 魔法によるダメージを出力する / Generate damage-dice info string such as "dam 2d10"
  61  * @param dice ダイス数
  62  * @param sides ダイス目
  63  * @param base 固定値
  64  * @return フォーマットに従い整形された文字列
  65  */
  66 concptr info_damage(DICE_NUMBER dice, DICE_SID sides, int base)
  67 {
  68         return info_string_dice(_("損傷:", "dam "), dice, sides, base);
  69 }
  70
  71 /*!
  72  * @brief 魔法の効果時間を出力する / Generate duration info string such as "dur 20+1d20"
  73  * @param base 固定値
  74  * @param sides ダイス目
  75  * @return フォーマットに従い整形された文字列
  76  */
  77 concptr info_duration(int base, DICE_SID sides)
  78 {
  79         return format(_("期間:%d+1d%d", "dur %d+1d%d"), base, sides);
  80 }
  81
  82 /*!
  83  * @brief 魔法の効果範囲を出力する / Generate range info string such as "range 5"
  84  * @param range 効果範囲
  85  * @return フォーマットに従い整形された文字列
  86  */
  87 concptr info_range(POSITION range)
  88 {
  89         return format(_("範囲:%d", "range %d"), range);
  90 }
  91
  92 /*!
  93  * @brief 魔法による回復量を出力する / Generate heal info string such as "heal 2d8"
  94  * @param dice ダイス数
  95  * @param sides ダイス目
  96  * @param base 固定値
  97  * @return フォーマットに従い整形された文字列
  98  */
  99 concptr info_heal(DICE_NUMBER dice, DICE_SID sides, int base)
 100 {
 101         return info_string_dice(_("回復:", "heal "), dice, sides, base);
 102 }
 103
 104 /*!
 105  * @brief 魔法効果発動までの遅延ターンを出力する / Generate delay info string such as "delay 15+1d15"
 106  * @param base 固定値
 107  * @param sides ダイス目
 108  * @return フォーマットに従い整形された文字列
 109  */
 110 concptr info_delay(int base, DICE_SID sides)
 111 {
 112         return format(_("遅延:%d+1d%d", "delay %d+1d%d"), base, sides);
 113 }
 114
 115
 116 /*!
 117  * @brief 魔法によるダメージを出力する(固定値＆複数回処理) / Generate multiple-damage info string such as "dam 25 each"
 118  * @param dam 固定値
 119  * @return フォーマットに従い整形された文字列
 120  */
 121 concptr info_multi_damage(HIT_POINT dam)
 122 {
 123         return format(_("損傷:各%d", "dam %d each"), dam);
 124 }
 125
 126
 127 /*!
 128  * @brief 魔法によるダメージを出力する(ダイスのみ＆複数回処理) / Generate multiple-damage-dice info string such as "dam 5d2 each"
 129  * @param dice ダイス数
 130  * @param sides ダイス目
 131  * @return フォーマットに従い整形された文字列
 132  */
 133 concptr info_multi_damage_dice(DICE_NUMBER dice, DICE_SID sides)
 134 {
 135         return format(_("損傷:各%dd%d", "dam %dd%d each"), dice, sides);
 136 }
 137
 138 /*!
 139  * @brief 魔法による一般的な効力値を出力する（固定値） / Generate power info string such as "power 100"
 140  * @param power 固定値
 141  * @return フォーマットに従い整形された文字列
 142  */
 143 concptr info_power(int power)
 144 {
 145         return format(_("効力:%d", "power %d"), power);
 146 }
 147
 148
 149 /*!
 150  * @brief 魔法による一般的な効力値を出力する（ダイス値） / Generate power info string such as "power 100"
 151  * @param dice ダイス数
 152  * @param sides ダイス目
 153  * @return フォーマットに従い整形された文字列
 154  */
 155 /*
 156  * Generate power info string such as "power 1d100"
 157  */
 158 concptr info_power_dice(DICE_NUMBER dice, DICE_SID sides)
 159 {
 160         return format(_("効力:%dd%d", "power %dd%d"), dice, sides);
 161 }
 162
 163
 164 /*!
 165  * @brief 魔法の効果半径を出力する / Generate radius info string such as "rad 100"
 166  * @param rad 効果半径
 167  * @return フォーマットに従い整形された文字列
 168  */
 169 concptr info_radius(POSITION rad)
 170 {
 171         return format(_("半径:%d", "rad %d"), rad);
 172 }
 173
 174
 175 /*!
 176  * @brief 魔法効果の限界重量を出力する / Generate weight info string such as "max wgt 15"
 177  * @param weight 最大重量
 178  * @return フォーマットに従い整形された文字列
 179  */
 180 concptr info_weight(WEIGHT weight)
 181 {
 182 #ifdef JP
 183         return format("最大重量:%d.%dkg", lbtokg1(weight), lbtokg2(weight));
 184 #else
 185         return format("max wgt %d", weight/10);
 186 #endif
 187 }
 188
 189 /*!
 190  * @brief 魔法が利用可能かどうかを返す /
 191  * Determine if a spell is "okay" for the player to cast or study
 192  * The spell must be legible, not forgotten, and also, to cast,
 193  * it must be known, and to study, it must not be known.
 194  * @param spell 呪文ID
 195  * @param learned 使用可能な判定ならばTRUE、学習可能かどうかの判定ならばFALSE
 196  * @param study_pray 祈りの学習判定目的ならばTRUE
 197  * @param use_realm 魔法領域ID
 198  * @return 失敗率(%)
 199  */
 200 static bool spell_okay(int spell, bool learned, bool study_pray, int use_realm)
 201 {
 202         const magic_type *s_ptr;
 203
 204         /* Access the spell */
 205         if (!is_magic(use_realm))
 206         {
 207                 s_ptr = &technic_info[use_realm - MIN_TECHNIC][spell];
 208         }
 209         else
 210         {
 211                 s_ptr = &mp_ptr->info[use_realm - 1][spell];
 212         }
 213
 214         /* Spell is illegal */
 215         if (s_ptr->slevel > p_ptr->lev) return (FALSE);
 216
 217         /* Spell is forgotten */
 218         if ((use_realm == p_ptr->realm2) ?
 219                 (p_ptr->spell_forgotten2 & (1L << spell)) :
 220                 (p_ptr->spell_forgotten1 & (1L << spell)))
 221         {
 222                 /* Never okay */
 223                 return (FALSE);
 224         }
 225
 226         if (p_ptr->pclass == CLASS_SORCERER) return (TRUE);
 227         if (p_ptr->pclass == CLASS_RED_MAGE) return (TRUE);
 228
 229         /* Spell is learned */
 230         if ((use_realm == p_ptr->realm2) ?
 231                 (p_ptr->spell_learned2 & (1L << spell)) :
 232                 (p_ptr->spell_learned1 & (1L << spell)))
 233         {
 234                 /* Always true */
 235                 return (!study_pray);
 236         }
 237
 238         /* Okay to study, not to cast */
 239         return (!learned);
 240 }
 241
 242
 243 /*!
 244  * @brief 魔法処理のメインルーチン
 245  * @param realm 魔法領域のID
 246  * @param spell 各領域の魔法ID
 247  * @param mode 求める処理
 248  * @return 各領域魔法に各種テキストを求めた場合は文字列参照ポインタ、そうでない場合はNULLポインタを返す。
 249  */
 250 concptr do_spell(REALM_IDX realm, SPELL_IDX spell, BIT_FLAGS mode)
 251 {
 252         switch (realm)
 253         {
 254         case REALM_LIFE:     return do_life_spell(spell, mode);
 255         case REALM_SORCERY:  return do_sorcery_spell(spell, mode);
 256         case REALM_NATURE:   return do_nature_spell(spell, mode);
 257         case REALM_CHAOS:    return do_chaos_spell(spell, mode);
 258         case REALM_DEATH:    return do_death_spell(spell, mode);
 259         case REALM_TRUMP:    return do_trump_spell(spell, mode);
 260         case REALM_ARCANE:   return do_arcane_spell(spell, mode);
 261         case REALM_CRAFT:    return do_craft_spell(spell, mode);
 262         case REALM_DAEMON:   return do_daemon_spell(spell, mode);
 263         case REALM_CRUSADE:  return do_crusade_spell(spell, mode);
 264         case REALM_MUSIC:    return do_music_spell(spell, mode);
 265         case REALM_HISSATSU: return do_hissatsu_spell(spell, mode);
 266         case REALM_HEX:      return do_hex_spell(spell, mode);
 267         }
 268
 269         return NULL;
 270 }
 271
 272
 273 /*!
 274  * @brief 領域魔法の閲覧、学習、使用選択するインターフェイス処理
 275  * Allow user to choose a spell/prayer from the given book.
 276  * @param sn 選択した魔法IDを返す参照ポインタ
 277  * @param prompt 魔法を利用する際の動詞表記
 278  * @param sval 魔道書のsval
 279  * @param learned 閲覧/使用選択ならばTRUE、学習処理ならFALSE
 280  * @param use_realm 魔法領域ID
 281  * @return
 282  * <pre>
 283  * If a valid spell is chosen, saves it in '*sn' and returns TRUE
 284  * If the user hits escape, returns FALSE, and set '*sn' to -1
 285  * If there are no legal choices, returns FALSE, and sets '*sn' to -2
 286  * The "prompt" should be "cast", "recite", or "study"
 287  * The "known" should be TRUE for cast/pray, FALSE for study
 288  * </pre>
 289  */
 290 static int get_spell(SPELL_IDX *sn, concptr prompt, OBJECT_SUBTYPE_VALUE sval, bool learned, REALM_IDX use_realm)
 291 {
 292         int i;
 293         SPELL_IDX spell = -1;
 294         int num = 0;
 295         int ask = TRUE;
 296         MANA_POINT need_mana;
 297         SPELL_IDX spells[64];
 298         bool flag, redraw, okay;
 299         char choice;
 300         const magic_type  *s_ptr;
 301         char out_val[160];
 302         concptr p;
 303         COMMAND_CODE code;
 304 #ifdef JP
 305         char jverb_buf[128];
 306 #endif
 307         int menu_line = (use_menu ? 1 : 0);
 308
 309         /* Get the spell, if available */
 310         if (repeat_pull(&code))
 311         {
 312                 *sn = (SPELL_IDX)code;
 313                 /* Verify the spell */
 314                 if (spell_okay(*sn, learned, FALSE, use_realm))
 315                 {
 316                         /* Success */
 317                         return (TRUE);
 318                 }
 319         }
 320
 321         p = spell_category_name(mp_ptr->spell_book);
 322
 323         /* Extract spells */
 324         for (spell = 0; spell < 32; spell++)
 325         {
 326                 /* Check for this spell */
 327                 if ((fake_spell_flags[sval] & (1L << spell)))
 328                 {
 329                         /* Collect this spell */
 330                         spells[num++] = spell;
 331                 }
 332         }
 333
 334         /* Assume no usable spells */
 335         okay = FALSE;
 336
 337         /* Assume no spells available */
 338         (*sn) = -2;
 339
 340         /* Check for "okay" spells */
 341         for (i = 0; i < num; i++)
 342         {
 343                 /* Look for "okay" spells */
 344                 if (spell_okay(spells[i], learned, FALSE, use_realm)) okay = TRUE;
 345         }
 346
 347         /* No "okay" spells */
 348         if (!okay) return (FALSE);
 349         if (((use_realm) != p_ptr->realm1) && ((use_realm) != p_ptr->realm2) && (p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return FALSE;
 350         if (((p_ptr->pclass == CLASS_SORCERER) || (p_ptr->pclass == CLASS_RED_MAGE)) && !is_magic(use_realm)) return FALSE;
 351         if ((p_ptr->pclass == CLASS_RED_MAGE) && ((use_realm) != REALM_ARCANE) && (sval > 1)) return FALSE;
 352
 353         /* Assume cancelled */
 354         *sn = (-1);
 355
 356         /* Nothing chosen yet */
 357         flag = FALSE;
 358
 359         /* No redraw yet */
 360         redraw = FALSE;
 361
 362         p_ptr->window |= (PW_SPELL);
 363         handle_stuff();
 364
 365         /* Build a prompt (accept all spells) */
 366 #ifdef JP
 367         jverb(prompt, jverb_buf, JVERB_AND);
 368         (void)strnfmt(out_val, 78, "(%^s:%c-%c, '*'で一覧, ESCで中断) どの%sを%^sますか? ",
 369                 p, I2A(0), I2A(num - 1), p, jverb_buf);
 370 #else
 371         (void)strnfmt(out_val, 78, "(%^ss %c-%c, *=List, ESC=exit) %^s which %s? ",
 372                 p, I2A(0), I2A(num - 1), prompt, p);
 373 #endif
 374
 375         choice = (always_show_list || use_menu) ? ESCAPE : 1;
 376         while (!flag)
 377         {
 378                 if (choice == ESCAPE) choice = ' ';
 379                 else if (!get_com(out_val, &choice, TRUE))break;
 380
 381                 if (use_menu && choice != ' ')
 382                 {
 383                         switch (choice)
 384                         {
 385                         case '0':
 386                         {
 387                                 screen_load();
 388                                 return FALSE;
 389                         }
 390
 391                         case '8':
 392                         case 'k':
 393                         case 'K':
 394                         {
 395                                 menu_line += (num - 1);
 396                                 break;
 397                         }
 398
 399                         case '2':
 400                         case 'j':
 401                         case 'J':
 402                         {
 403                                 menu_line++;
 404                                 break;
 405                         }
 406
 407                         case 'x':
 408                         case 'X':
 409                         case '\r':
 410                         case '\n':
 411                         {
 412                                 i = menu_line - 1;
 413                                 ask = FALSE;
 414                                 break;
 415                         }
 416                         }
 417                         if (menu_line > num) menu_line -= num;
 418                         /* Display a list of spells */
 419                         print_spells(menu_line, spells, num, 1, 15, use_realm);
 420                         if (ask) continue;
 421                 }
 422                 else
 423                 {
 424                         /* Request redraw */
 425                         if ((choice == ' ') || (choice == '*') || (choice == '?'))
 426                         {
 427                                 /* Show the list */
 428                                 if (!redraw)
 429                                 {
 430                                         redraw = TRUE;
 431                                         screen_save();
 432
 433                                         /* Display a list of spells */
 434                                         print_spells(menu_line, spells, num, 1, 15, use_realm);
 435                                 }
 436
 437                                 /* Hide the list */
 438                                 else
 439                                 {
 440                                         if (use_menu) continue;
 441
 442                                         /* Hide list */
 443                                         redraw = FALSE;
 444                                         screen_load();
 445                                 }
 446
 447                                 /* Redo asking */
 448                                 continue;
 449                         }
 450
 451
 452                         /* Note verify */
 453                         ask = (isupper(choice));
 454
 455                         /* Lowercase */
 456                         if (ask) choice = (char)tolower(choice);
 457
 458                         /* Extract request */
 459                         i = (islower(choice) ? A2I(choice) : -1);
 460                 }
 461
 462                 /* Totally Illegal */
 463                 if ((i < 0) || (i >= num))
 464                 {
 465                         bell();
 466                         continue;
 467                 }
 468
 469                 /* Save the spell index */
 470                 spell = spells[i];
 471
 472                 /* Require "okay" spells */
 473                 if (!spell_okay(spell, learned, FALSE, use_realm))
 474                 {
 475                         bell();
 476 #ifdef JP
 477                         msg_format("その%sを%sことはできません。", p, prompt);
 478 #else
 479                         msg_format("You may not %s that %s.", prompt, p);
 480 #endif
 481
 482                         continue;
 483                 }
 484
 485                 /* Verify it */
 486                 if (ask)
 487                 {
 488                         char tmp_val[160];
 489
 490                         /* Access the spell */
 491                         if (!is_magic(use_realm))
 492                         {
 493                                 s_ptr = &technic_info[use_realm - MIN_TECHNIC][spell];
 494                         }
 495                         else
 496                         {
 497                                 s_ptr = &mp_ptr->info[use_realm - 1][spell];
 498                         }
 499
 500                         /* Extract mana consumption rate */
 501                         if (use_realm == REALM_HISSATSU)
 502                         {
 503                                 need_mana = s_ptr->smana;
 504                         }
 505                         else
 506                         {
 507                                 need_mana = mod_need_mana(s_ptr->smana, spell, use_realm);
 508                         }
 509
 510                         /* Prompt */
 511 #ifdef JP
 512                         jverb(prompt, jverb_buf, JVERB_AND);
 513                         /* 英日切り替え機能に対応 */
 514                         (void)strnfmt(tmp_val, 78, "%s(MP%d, 失敗率%d%%)を%sますか? ",
 515                                 do_spell(use_realm, spell, SPELL_NAME), need_mana,
 516                                 spell_chance(spell, use_realm), jverb_buf);
 517 #else
 518                         (void)strnfmt(tmp_val, 78, "%^s %s (%d mana, %d%% fail)? ",
 519                                 prompt, do_spell(use_realm, spell, SPELL_NAME), need_mana,
 520                                 spell_chance(spell, use_realm));
 521 #endif
 522
 523
 524                         /* Belay that order */
 525                         if (!get_check(tmp_val)) continue;
 526                 }
 527
 528                 /* Stop the loop */
 529                 flag = TRUE;
 530         }
 531
 532         if (redraw) screen_load();
 533
 534         p_ptr->window |= (PW_SPELL);
 535         handle_stuff();
 536
 537         /* Abort if needed */
 538         if (!flag) return FALSE;
 539
 540         /* Save the choice */
 541         (*sn) = spell;
 542
 543         repeat_push((COMMAND_CODE)spell);
 544
 545         /* Success */
 546         return TRUE;
 547 }
 548
 549 /*!
 550  * @brief プレイヤーの職業が練気術師の時、領域魔法と練気術を切り換える処理のインターフェイス
 551  * @param browse_only 魔法と技能の閲覧を行うならばTRUE
 552  * @return 魔道書を一冊も持っていないならTRUEを返す
 553  */
 554 static void confirm_use_force(bool browse_only)
 555 {
 556         char which;
 557         COMMAND_CODE code;
 558
 559         /* Get the item index */
 560         if (repeat_pull(&code) && (code == INVEN_FORCE))
 561         {
 562                 browse_only ? do_cmd_mind_browse() : do_cmd_mind();
 563                 return;
 564         }
 565
 566         /* Show the prompt */
 567         prt(_("('w'練気術, ESC) 'w'かESCを押してください。 ", "(w for the Force, ESC) Hit 'w' or ESC. "), 0, 0);
 568
 569         while (1)
 570         {
 571                 /* Get a key */
 572                 which = inkey();
 573
 574                 if (which == ESCAPE) break;
 575                 else if (which == 'w')
 576                 {
 577                         repeat_push(INVEN_FORCE);
 578                         break;
 579                 }
 580         }
 581
 582         /* Clear the prompt line */
 583         prt("", 0, 0);
 584
 585         if (which == 'w')
 586         {
 587                 browse_only ? do_cmd_mind_browse() : do_cmd_mind();
 588         }
 589 }
 590
 591
 592 /*!
 593  * @brief プレイヤーの魔法と技能を閲覧するコマンドのメインルーチン /
 594  * Peruse the spells/prayers in a book
 595  * @return なし
 596  * @details
 597  * <pre>
 598  * Note that *all* spells in the book are listed
 599  *
 600  * Note that browsing is allowed while confused or blind,
 601  * and in the dark, primarily to allow browsing in stores.
 602  * </pre>
 603  */
 604 void do_cmd_browse(void)
 605 {
 606         OBJECT_IDX item;
 607         OBJECT_SUBTYPE_VALUE sval;
 608         REALM_IDX use_realm = 0;
 609         int j, line;
 610         SPELL_IDX spell = -1;
 611         int num = 0;
 612
 613         SPELL_IDX spells[64];
 614         char temp[62 * 4];
 615
 616         object_type *o_ptr;
 617
 618         concptr q, s;
 619
 620         /* Warriors are illiterate */
 621         if (!(p_ptr->realm1 || p_ptr->realm2) && (p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE))
 622         {
 623                 msg_print(_("本を読むことができない！", "You cannot read books!"));
 624                 return;
 625         }
 626
 627         if (p_ptr->special_defense & KATA_MUSOU)
 628         {
 629                 set_action(ACTION_NONE);
 630         }
 631
 632         if (p_ptr->pclass == CLASS_FORCETRAINER)
 633         {
 634                 if (player_has_no_spellbooks())
 635                 {
 636                         confirm_use_force(TRUE);
 637                         return;
 638                 }
 639         }
 640
 641         /* Restrict choices to "useful" books */
 642         if (p_ptr->realm2 == REALM_NONE) item_tester_tval = mp_ptr->spell_book;
 643         else item_tester_hook = item_tester_learn_spell;
 644
 645         q = _("どの本を読みますか? ", "Browse which book? ");
 646         s = _("読める本がない。", "You have no books that you can read.");
 647
 648         o_ptr = choose_object(&item, q, s, (USE_INVEN | USE_FLOOR | (p_ptr->pclass == CLASS_FORCETRAINER ? USE_FORCE : 0)));
 649         if (!o_ptr)
 650         {
 651                 if (item == INVEN_FORCE) /* the_force */
 652                 {
 653                         do_cmd_mind_browse();
 654                         return;
 655                 }
 656                 return;
 657         }
 658
 659         /* Access the item's sval */
 660         sval = o_ptr->sval;
 661
 662         use_realm = tval2realm(o_ptr->tval);
 663
 664         /* Track the object kind */
 665         object_kind_track(o_ptr->k_idx);
 666         handle_stuff();
 667
 668         /* Extract spells */
 669         for (spell = 0; spell < 32; spell++)
 670         {
 671                 /* Check for this spell */
 672                 if ((fake_spell_flags[sval] & (1L << spell)))
 673                 {
 674                         /* Collect this spell */
 675                         spells[num++] = spell;
 676                 }
 677         }
 678
 679         screen_save();
 680         prt("", 0, 0);
 681
 682         /* Keep browsing spells.  Exit browsing on cancel. */
 683         while (TRUE)
 684         {
 685                 /* Ask for a spell, allow cancel */
 686                 if (!get_spell(&spell, _("読む", "browse"), o_ptr->sval, TRUE, use_realm))
 687                 {
 688                         /* If cancelled, leave immediately. */
 689                         if (spell == -1) break;
 690
 691                         /* Display a list of spells */
 692                         print_spells(0, spells, num, 1, 15, use_realm);
 693
 694                         /* Notify that there's nothing to see, and wait. */
 695                         if (use_realm == REALM_HISSATSU)
 696                                 prt(_("読める技がない。", "No techniques to browse."), 0, 0);
 697                         else
 698                                 prt(_("読める呪文がない。", "No spells to browse."), 0, 0);
 699                         (void)inkey();
 700
 701                         screen_load();
 702
 703                         return;
 704                 }
 705
 706                 /* Clear lines, position cursor  (really should use strlen here) */
 707                 Term_erase(14, 14, 255);
 708                 Term_erase(14, 13, 255);
 709                 Term_erase(14, 12, 255);
 710                 Term_erase(14, 11, 255);
 711
 712                 roff_to_buf(do_spell(use_realm, spell, SPELL_DESC), 62, temp, sizeof(temp));
 713
 714                 for (j = 0, line = 11; temp[j]; j += 1 + strlen(&temp[j]))
 715                 {
 716                         prt(&temp[j], line, 15);
 717                         line++;
 718                 }
 719         }
 720         screen_load();
 721 }
 722
 723 /*!
 724  * @brief プレイヤーの第二魔法領域を変更する /
 725  * @param next_realm 変更先の魔法領域ID
 726  * @return なし
 727  */
 728 static void change_realm2(CHARACTER_IDX next_realm)
 729 {
 730         int i, j = 0;
 731         char tmp[80];
 732
 733         for (i = 0; i < 64; i++)
 734         {
 735                 p_ptr->spell_order[j] = p_ptr->spell_order[i];
 736                 if (p_ptr->spell_order[i] < 32) j++;
 737         }
 738         for (; j < 64; j++)
 739                 p_ptr->spell_order[j] = 99;
 740
 741         for (i = 32; i < 64; i++)
 742         {
 743                 p_ptr->spell_exp[i] = SPELL_EXP_UNSKILLED;
 744         }
 745         p_ptr->spell_learned2 = 0L;
 746         p_ptr->spell_worked2 = 0L;
 747         p_ptr->spell_forgotten2 = 0L;
 748
 749         sprintf(tmp, _("魔法の領域を%sから%sに変更した。", "change magic realm from %s to %s."), realm_names[p_ptr->realm2], realm_names[next_realm]);
 750         do_cmd_write_nikki(NIKKI_BUNSHOU, 0, tmp);
 751         p_ptr->old_realm |= 1 << (p_ptr->realm2 - 1);
 752         p_ptr->realm2 = next_realm;
 753
 754         p_ptr->update |= (PU_REORDER);
 755         p_ptr->update |= (PU_SPELLS);
 756         handle_stuff();
 757
 758         /* Load an autopick preference file */
 759         autopick_load_pref(FALSE);
 760 }
 761
 762
 763 /*!
 764  * @brief 魔法を学習するコマンドのメインルーチン /
 765  * Study a book to gain a new spell/prayer
 766  * @return なし
 767  */
 768 void do_cmd_study(void)
 769 {
 770         int     i;
 771         OBJECT_IDX item;
 772         OBJECT_SUBTYPE_VALUE sval;
 773         int     increment = 0;
 774         bool    learned = FALSE;
 775
 776         /* Spells of realm2 will have an increment of +32 */
 777         SPELL_IDX spell = -1;
 778
 779         concptr p = spell_category_name(mp_ptr->spell_book);
 780
 781         object_type *o_ptr;
 782
 783         concptr q, s;
 784
 785         if (!p_ptr->realm1)
 786         {
 787                 msg_print(_("本を読むことができない！", "You cannot read books!"));
 788                 return;
 789         }
 790
 791         if (p_ptr->blind || no_lite())
 792         {
 793                 msg_print(_("目が見えない！", "You cannot see!"));
 794                 return;
 795         }
 796
 797         if (cmd_limit_confused(p_ptr)) return;
 798
 799         if (!(p_ptr->new_spells))
 800         {
 801                 msg_format(_("新しい%sを覚えることはできない！", "You cannot learn any new %ss!"), p);
 802                 return;
 803         }
 804
 805         if (p_ptr->special_defense & KATA_MUSOU)
 806         {
 807                 set_action(ACTION_NONE);
 808         }
 809
 810 #ifdef JP
 811         if (p_ptr->new_spells < 10) {
 812                 msg_format("あと %d つの%sを学べる。", p_ptr->new_spells, p);
 813         }
 814         else {
 815                 msg_format("あと %d 個の%sを学べる。", p_ptr->new_spells, p);
 816         }
 817 #else
 818         msg_format("You can learn %d new %s%s.", p_ptr->new_spells, p,
 819                 (p_ptr->new_spells == 1 ? "" : "s"));
 820 #endif
 821
 822         msg_print(NULL);
 823
 824
 825         /* Restrict choices to "useful" books */
 826         if (p_ptr->realm2 == REALM_NONE) item_tester_tval = mp_ptr->spell_book;
 827         else item_tester_hook = item_tester_learn_spell;
 828
 829         q = _("どの本から学びますか? ", "Study which book? ");
 830         s = _("読める本がない。", "You have no books that you can read.");
 831
 832         o_ptr = choose_object(&item, q, s, (USE_INVEN | USE_FLOOR));
 833         if (!o_ptr) return;
 834
 835         /* Access the item's sval */
 836         sval = o_ptr->sval;
 837
 838         if (o_ptr->tval == REALM2_BOOK) increment = 32;
 839         else if (o_ptr->tval != REALM1_BOOK)
 840         {
 841                 if (!get_check(_("本当に魔法の領域を変更しますか？", "Really, change magic realm? "))) return;
 842                 change_realm2(tval2realm(o_ptr->tval));
 843                 increment = 32;
 844         }
 845
 846         /* Track the object kind */
 847         object_kind_track(o_ptr->k_idx);
 848         handle_stuff();
 849
 850         /* Mage -- Learn a selected spell */
 851         if (mp_ptr->spell_book != TV_LIFE_BOOK)
 852         {
 853                 /* Ask for a spell, allow cancel */
 854                 if (!get_spell(&spell, _("学ぶ", "study"), sval, FALSE, o_ptr->tval - TV_LIFE_BOOK + 1) && (spell == -1)) return;
 855         }
 856
 857         /* Priest -- Learn a random prayer */
 858         else
 859         {
 860                 int k = 0;
 861                 int gift = -1;
 862
 863                 /* Extract spells */
 864                 for (spell = 0; spell < 32; spell++)
 865                 {
 866                         /* Check spells in the book */
 867                         if ((fake_spell_flags[sval] & (1L << spell)))
 868                         {
 869                                 /* Skip non "okay" prayers */
 870                                 if (!spell_okay(spell, FALSE, TRUE,
 871                                         (increment ? p_ptr->realm2 : p_ptr->realm1))) continue;
 872
 873                                 /* Hack -- Prepare the randomizer */
 874                                 k++;
 875
 876                                 /* Hack -- Apply the randomizer */
 877                                 if (one_in_(k)) gift = spell;
 878                         }
 879                 }
 880
 881                 /* Accept gift */
 882                 spell = gift;
 883         }
 884
 885         /* Nothing to study */
 886         if (spell < 0)
 887         {
 888                 msg_format(_("その本には学ぶべき%sがない。", "You cannot learn any %ss in that book."), p);
 889
 890                 /* Abort */
 891                 return;
 892         }
 893
 894         if (increment) spell += increment;
 895
 896         /* Learn the spell */
 897         if (spell < 32)
 898         {
 899                 if (p_ptr->spell_learned1 & (1L << spell)) learned = TRUE;
 900                 else p_ptr->spell_learned1 |= (1L << spell);
 901         }
 902         else
 903         {
 904                 if (p_ptr->spell_learned2 & (1L << (spell - 32))) learned = TRUE;
 905                 else p_ptr->spell_learned2 |= (1L << (spell - 32));
 906         }
 907
 908         if (learned)
 909         {
 910                 int max_exp = (spell < 32) ? SPELL_EXP_MASTER : SPELL_EXP_EXPERT;
 911                 int old_exp = p_ptr->spell_exp[spell];
 912                 int new_rank = EXP_LEVEL_UNSKILLED;
 913                 concptr name = do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell % 32, SPELL_NAME);
 914
 915                 if (old_exp >= max_exp)
 916                 {
 917                         msg_format(_("その%sは完全に使いこなせるので学ぶ必要はない。", "You don't need to study this %s anymore."), p);
 918                         return;
 919                 }
 920 #ifdef JP
 921                 if (!get_check(format("%sの%sをさらに学びます。よろしいですか？", name, p)))
 922 #else
 923                 if (!get_check(format("You will study a %s of %s again. Are you sure? ", p, name)))
 924 #endif
 925                 {
 926                         return;
 927                 }
 928                 else if (old_exp >= SPELL_EXP_EXPERT)
 929                 {
 930                         p_ptr->spell_exp[spell] = SPELL_EXP_MASTER;
 931                         new_rank = EXP_LEVEL_MASTER;
 932                 }
 933                 else if (old_exp >= SPELL_EXP_SKILLED)
 934                 {
 935                         if (spell >= 32) p_ptr->spell_exp[spell] = SPELL_EXP_EXPERT;
 936                         else p_ptr->spell_exp[spell] += SPELL_EXP_EXPERT - SPELL_EXP_SKILLED;
 937                         new_rank = EXP_LEVEL_EXPERT;
 938                 }
 939                 else if (old_exp >= SPELL_EXP_BEGINNER)
 940                 {
 941                         p_ptr->spell_exp[spell] = SPELL_EXP_SKILLED + (old_exp - SPELL_EXP_BEGINNER) * 2 / 3;
 942                         new_rank = EXP_LEVEL_SKILLED;
 943                 }
 944                 else
 945                 {
 946                         p_ptr->spell_exp[spell] = SPELL_EXP_BEGINNER + old_exp / 3;
 947                         new_rank = EXP_LEVEL_BEGINNER;
 948                 }
 949                 msg_format(_("%sの熟練度が%sに上がった。", "Your proficiency of %s is now %s rank."), name, exp_level_str[new_rank]);
 950         }
 951         else
 952         {
 953                 /* Find the next open entry in "p_ptr->spell_order[]" */
 954                 for (i = 0; i < 64; i++)
 955                 {
 956                         /* Stop at the first empty space */
 957                         if (p_ptr->spell_order[i] == 99) break;
 958                 }
 959
 960                 /* Add the spell to the known list */
 961                 p_ptr->spell_order[i++] = spell;
 962
 963                 /* Mention the result */
 964 #ifdef JP
 965                 /* 英日切り替え機能に対応 */
 966                 if (mp_ptr->spell_book == TV_MUSIC_BOOK)
 967                 {
 968                         msg_format("%sを学んだ。",
 969                                 do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell % 32, SPELL_NAME));
 970                 }
 971                 else
 972                 {
 973                         msg_format("%sの%sを学んだ。",
 974                                 do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell % 32, SPELL_NAME), p);
 975                 }
 976 #else
 977                 msg_format("You have learned the %s of %s.",
 978                         p, do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell % 32, SPELL_NAME));
 979 #endif
 980         }
 981
 982         take_turn(p_ptr, 100);
 983
 984         switch (mp_ptr->spell_book)
 985         {
 986         case TV_LIFE_BOOK:
 987                 chg_virtue(V_FAITH, 1);
 988                 break;
 989         case TV_DEATH_BOOK:
 990                 chg_virtue(V_UNLIFE, 1);
 991                 break;
 992         case TV_NATURE_BOOK:
 993                 chg_virtue(V_NATURE, 1);
 994                 break;
 995         default:
 996                 chg_virtue(V_KNOWLEDGE, 1);
 997                 break;
 998         }
 999
1000         sound(SOUND_STUDY);
1001
1002         /* One less spell available */
1003         p_ptr->learned_spells++;
1004
1005         /* Update Study */
1006         p_ptr->update |= (PU_SPELLS);
1007         update_creature(p_ptr);
1008
1009         /* Redraw object recall */
1010         p_ptr->window |= (PW_OBJECT);
1011 }
1012
1013
1014 /*!
1015  * @brief 魔法を詠唱するコマンドのメインルーチン /
1016  * Cast a spell
1017  * @return なし
1018  */
1019 void do_cmd_cast(void)
1020 {
1021         OBJECT_IDX item;
1022         OBJECT_SUBTYPE_VALUE sval;
1023         SPELL_IDX spell;
1024         REALM_IDX realm;
1025         int     chance;
1026         int     increment = 0;
1027         REALM_IDX use_realm;
1028         MANA_POINT need_mana;
1029
1030         concptr prayer;
1031         object_type *o_ptr;
1032         const magic_type *s_ptr;
1033         concptr q, s;
1034
1035         bool over_exerted = FALSE;
1036
1037         /* Require spell ability */
1038         if (!p_ptr->realm1 && (p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE))
1039         {
1040                 msg_print(_("呪文を唱えられない！", "You cannot cast spells!"));
1041                 return;
1042         }
1043
1044         /* Require lite */
1045         if (p_ptr->blind || no_lite())
1046         {
1047                 if (p_ptr->pclass == CLASS_FORCETRAINER) confirm_use_force(FALSE);
1048                 else
1049                 {
1050                         msg_print(_("目が見えない！", "You cannot see!"));
1051                         flush();
1052                 }
1053                 return;
1054         }
1055
1056         if (cmd_limit_confused(p_ptr)) return;
1057
1058         /* Hex */
1059         if (p_ptr->realm1 == REALM_HEX)
1060         {
1061                 if (hex_spell_fully())
1062                 {
1063                         bool flag = FALSE;
1064                         msg_print(_("これ以上新しい呪文を詠唱することはできない。", "Can not spell new spells more."));
1065                         flush();
1066                         if (p_ptr->lev >= 35) flag = stop_hex_spell();
1067                         if (!flag) return;
1068                 }
1069         }
1070
1071         if (p_ptr->pclass == CLASS_FORCETRAINER)
1072         {
1073                 if (player_has_no_spellbooks())
1074                 {
1075                         confirm_use_force(FALSE);
1076                         return;
1077                 }
1078         }
1079
1080         prayer = spell_category_name(mp_ptr->spell_book);
1081
1082         /* Restrict choices to spell books */
1083         item_tester_tval = mp_ptr->spell_book;
1084
1085         q = _("どの呪文書を使いますか? ", "Use which book? ");
1086         s = _("呪文書がない！", "You have no spell books!");
1087
1088         o_ptr = choose_object(&item, q, s, (USE_INVEN | USE_FLOOR | (p_ptr->pclass == CLASS_FORCETRAINER ? USE_FORCE : 0)));
1089         if (!o_ptr)
1090         {
1091                 if (item == INVEN_FORCE) /* the_force */
1092                 {
1093                         do_cmd_mind();
1094                         return;
1095                 }
1096                 return;
1097         }
1098
1099         /* Access the item's sval */
1100         sval = o_ptr->sval;
1101
1102         if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE) && (o_ptr->tval == REALM2_BOOK)) increment = 32;
1103
1104         /* Track the object kind */
1105         object_kind_track(o_ptr->k_idx);
1106         handle_stuff();
1107
1108         if ((p_ptr->pclass == CLASS_SORCERER) || (p_ptr->pclass == CLASS_RED_MAGE))
1109                 realm = o_ptr->tval - TV_LIFE_BOOK + 1;
1110         else if (increment) realm = p_ptr->realm2;
1111         else realm = p_ptr->realm1;
1112
1113         /* Ask for a spell */
1114 #ifdef JP
1115         if (!get_spell(&spell, ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "詠唱する" : (mp_ptr->spell_book == TV_MUSIC_BOOK) ? "歌う" : "唱える"),
1116                 sval, TRUE, realm))
1117         {
1118                 if (spell == -2) msg_format("その本には知っている%sがない。", prayer);
1119                 return;
1120         }
1121 #else
1122         if (!get_spell(&spell, ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "recite" : "cast"),
1123                 sval, TRUE, realm))
1124         {
1125                 if (spell == -2)
1126                         msg_format("You don't know any %ss in that book.", prayer);
1127                 return;
1128         }
1129 #endif
1130
1131
1132         use_realm = tval2realm(o_ptr->tval);
1133
1134         /* Hex */
1135         if (use_realm == REALM_HEX)
1136         {
1137                 if (hex_spelling(spell))
1138                 {
1139                         msg_print(_("その呪文はすでに詠唱中だ。", "You are already casting it."));
1140                         return;
1141                 }
1142         }
1143
1144         if (!is_magic(use_realm))
1145         {
1146                 s_ptr = &technic_info[use_realm - MIN_TECHNIC][spell];
1147         }
1148         else
1149         {
1150                 s_ptr = &mp_ptr->info[realm - 1][spell];
1151         }
1152
1153         /* Extract mana consumption rate */
1154         need_mana = mod_need_mana(s_ptr->smana, spell, realm);
1155
1156         /* Verify "dangerous" spells */
1157         if (need_mana > p_ptr->csp)
1158         {
1159                 if (flush_failure) flush();
1160
1161                 /* Warning */
1162 #ifdef JP
1163                 msg_format("その%sを%sのに十分なマジックポイントがない。", prayer,
1164                         ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "詠唱する" : (mp_ptr->spell_book == TV_LIFE_BOOK) ? "歌う" : "唱える"));
1165 #else
1166                 msg_format("You do not have enough mana to %s this %s.",
1167                         ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "recite" : "cast"),
1168                         prayer);
1169 #endif
1170
1171
1172                 if (!over_exert) return;
1173
1174                 /* Verify */
1175                 if (!get_check_strict(_("それでも挑戦しますか? ", "Attempt it anyway? "), CHECK_OKAY_CANCEL)) return;
1176         }
1177
1178         /* Spell failure chance */
1179         chance = spell_chance(spell, use_realm);
1180
1181         /* Sufficient mana */
1182         if (need_mana <= p_ptr->csp)
1183         {
1184                 /* Use some mana */
1185                 p_ptr->csp -= need_mana;
1186         }
1187         else over_exerted = TRUE;
1188         p_ptr->redraw |= (PR_MANA);
1189
1190         /* Failed spell */
1191         if (randint0(100) < chance)
1192         {
1193                 if (flush_failure) flush();
1194
1195                 msg_format(_("%sをうまく唱えられなかった！", "You failed to get the %s off!"), prayer);
1196                 sound(SOUND_FAIL);
1197
1198                 switch (realm)
1199                 {
1200                 case REALM_LIFE:
1201                         if (randint1(100) < chance) chg_virtue(V_VITALITY, -1);
1202                         break;
1203                 case REALM_DEATH:
1204                         if (randint1(100) < chance) chg_virtue(V_UNLIFE, -1);
1205                         break;
1206                 case REALM_NATURE:
1207                         if (randint1(100) < chance) chg_virtue(V_NATURE, -1);
1208                         break;
1209                 case REALM_DAEMON:
1210                         if (randint1(100) < chance) chg_virtue(V_JUSTICE, 1);
1211                         break;
1212                 case REALM_CRUSADE:
1213                         if (randint1(100) < chance) chg_virtue(V_JUSTICE, -1);
1214                         break;
1215                 case REALM_HEX:
1216                         if (randint1(100) < chance) chg_virtue(V_COMPASSION, -1);
1217                         break;
1218                 default:
1219                         if (randint1(100) < chance) chg_virtue(V_KNOWLEDGE, -1);
1220                         break;
1221                 }
1222
1223                 /* Failure casting may activate some side effect */
1224                 do_spell(realm, spell, SPELL_FAIL);
1225
1226
1227                 if ((o_ptr->tval == TV_CHAOS_BOOK) && (randint1(100) < spell))
1228                 {
1229                         msg_print(_("カオス的な効果を発生した！", "You produce a chaotic effect!"));
1230                         wild_magic(spell);
1231                 }
1232                 else if ((o_ptr->tval == TV_DEATH_BOOK) && (randint1(100) < spell))
1233                 {
1234                         if ((sval == 3) && one_in_(2))
1235                         {
1236                                 sanity_blast(0, TRUE);
1237                         }
1238                         else
1239                         {
1240                                 msg_print(_("痛い！", "It hurts!"));
1241                                 take_hit(DAMAGE_LOSELIFE, damroll(o_ptr->sval + 1, 6), _("暗黒魔法の逆流", "a miscast Death spell"), -1);
1242
1243                                 if ((spell > 15) && one_in_(6) && !p_ptr->hold_exp)
1244                                         lose_exp(spell * 250);
1245                         }
1246                 }
1247                 else if ((o_ptr->tval == TV_MUSIC_BOOK) && (randint1(200) < spell))
1248                 {
1249                         msg_print(_("いやな音が響いた", "An infernal sound echoed."));
1250                         aggravate_monsters(0);
1251                 }
1252                 if (randint1(100) >= chance)
1253                         chg_virtue(V_CHANCE, -1);
1254         }
1255
1256         /* Process spell */
1257         else
1258         {
1259                 /* Canceled spells cost neither a current_world_ptr->game_turn nor mana */
1260                 if (!do_spell(realm, spell, SPELL_CAST)) return;
1261
1262                 if (randint1(100) < chance)
1263                         chg_virtue(V_CHANCE, 1);
1264
1265                 /* A spell was cast */
1266                 if (!(increment ?
1267                         (p_ptr->spell_worked2 & (1L << spell)) :
1268                         (p_ptr->spell_worked1 & (1L << spell)))
1269                         && (p_ptr->pclass != CLASS_SORCERER)
1270                         && (p_ptr->pclass != CLASS_RED_MAGE))
1271                 {
1272                         int e = s_ptr->sexp;
1273
1274                         /* The spell worked */
1275                         if (realm == p_ptr->realm1)
1276                         {
1277                                 p_ptr->spell_worked1 |= (1L << spell);
1278                         }
1279                         else
1280                         {
1281                                 p_ptr->spell_worked2 |= (1L << spell);
1282                         }
1283
1284                         /* Gain experience */
1285                         gain_exp(e * s_ptr->slevel);
1286
1287                         /* Redraw object recall */
1288                         p_ptr->window |= (PW_OBJECT);
1289
1290                         switch (realm)
1291                         {
1292                         case REALM_LIFE:
1293                                 chg_virtue(V_TEMPERANCE, 1);
1294                                 chg_virtue(V_COMPASSION, 1);
1295                                 chg_virtue(V_VITALITY, 1);
1296                                 chg_virtue(V_DILIGENCE, 1);
1297                                 break;
1298                         case REALM_DEATH:
1299                                 chg_virtue(V_UNLIFE, 1);
1300                                 chg_virtue(V_JUSTICE, -1);
1301                                 chg_virtue(V_FAITH, -1);
1302                                 chg_virtue(V_VITALITY, -1);
1303                                 break;
1304                         case REALM_DAEMON:
1305                                 chg_virtue(V_JUSTICE, -1);
1306                                 chg_virtue(V_FAITH, -1);
1307                                 chg_virtue(V_HONOUR, -1);
1308                                 chg_virtue(V_TEMPERANCE, -1);
1309                                 break;
1310                         case REALM_CRUSADE:
1311                                 chg_virtue(V_FAITH, 1);
1312                                 chg_virtue(V_JUSTICE, 1);
1313                                 chg_virtue(V_SACRIFICE, 1);
1314                                 chg_virtue(V_HONOUR, 1);
1315                                 break;
1316                         case REALM_NATURE:
1317                                 chg_virtue(V_NATURE, 1);
1318                                 chg_virtue(V_HARMONY, 1);
1319                                 break;
1320                         case REALM_HEX:
1321                                 chg_virtue(V_JUSTICE, -1);
1322                                 chg_virtue(V_FAITH, -1);
1323                                 chg_virtue(V_HONOUR, -1);
1324                                 chg_virtue(V_COMPASSION, -1);
1325                                 break;
1326                         default:
1327                                 chg_virtue(V_KNOWLEDGE, 1);
1328                                 break;
1329                         }
1330                 }
1331                 switch (realm)
1332                 {
1333                 case REALM_LIFE:
1334                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_TEMPERANCE, 1);
1335                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_COMPASSION, 1);
1336                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_VITALITY, 1);
1337                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_DILIGENCE, 1);
1338                         break;
1339                 case REALM_DEATH:
1340                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_UNLIFE, 1);
1341                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, -1);
1342                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, -1);
1343                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_VITALITY, -1);
1344                         break;
1345                 case REALM_DAEMON:
1346                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, -1);
1347                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, -1);
1348                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HONOUR, -1);
1349                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_TEMPERANCE, -1);
1350                         break;
1351                 case REALM_CRUSADE:
1352                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, 1);
1353                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, 1);
1354                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_SACRIFICE, 1);
1355                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HONOUR, 1);
1356                         break;
1357                 case REALM_NATURE:
1358                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_NATURE, 1);
1359                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HARMONY, 1);
1360                         break;
1361                 case REALM_HEX:
1362                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, -1);
1363                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, -1);
1364                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HONOUR, -1);
1365                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_COMPASSION, -1);
1366                         break;
1367                 }
1368                 if (mp_ptr->spell_xtra & MAGIC_GAIN_EXP)
1369                 {
1370                         s16b cur_exp = p_ptr->spell_exp[(increment ? 32 : 0) + spell];
1371                         s16b exp_gain = 0;
1372
1373                         if (cur_exp < SPELL_EXP_BEGINNER)
1374                                 exp_gain += 60;
1375                         else if (cur_exp < SPELL_EXP_SKILLED)
1376                         {
1377                                 if ((current_floor_ptr->dun_level > 4) && ((current_floor_ptr->dun_level + 10) > p_ptr->lev))
1378                                         exp_gain = 8;
1379                         }
1380                         else if (cur_exp < SPELL_EXP_EXPERT)
1381                         {
1382                                 if (((current_floor_ptr->dun_level + 5) > p_ptr->lev) && ((current_floor_ptr->dun_level + 5) > s_ptr->slevel))
1383                                         exp_gain = 2;
1384                         }
1385                         else if ((cur_exp < SPELL_EXP_MASTER) && !increment)
1386                         {
1387                                 if (((current_floor_ptr->dun_level + 5) > p_ptr->lev) && (current_floor_ptr->dun_level > s_ptr->slevel))
1388                                         exp_gain = 1;
1389                         }
1390                         p_ptr->spell_exp[(increment ? 32 : 0) + spell] += exp_gain;
1391                 }
1392         }
1393
1394         take_turn(p_ptr, 100);
1395
1396
1397         /* Over-exert the player */
1398         if (over_exerted)
1399         {
1400                 int oops = need_mana;
1401
1402                 /* No mana left */
1403                 p_ptr->csp = 0;
1404                 p_ptr->csp_frac = 0;
1405
1406                 msg_print(_("精神を集中しすぎて気を失ってしまった！", "You faint from the effort!"));
1407
1408                 /* Hack -- Bypass free action */
1409                 (void)set_paralyzed(p_ptr->paralyzed + randint1(5 * oops + 1));
1410
1411                 switch (realm)
1412                 {
1413                 case REALM_LIFE:
1414                         chg_virtue(V_VITALITY, -10);
1415                         break;
1416                 case REALM_DEATH:
1417                         chg_virtue(V_UNLIFE, -10);
1418                         break;
1419                 case REALM_DAEMON:
1420                         chg_virtue(V_JUSTICE, 10);
1421                         break;
1422                 case REALM_NATURE:
1423                         chg_virtue(V_NATURE, -10);
1424                         break;
1425                 case REALM_CRUSADE:
1426                         chg_virtue(V_JUSTICE, -10);
1427                         break;
1428                 case REALM_HEX:
1429                         chg_virtue(V_COMPASSION, 10);
1430                         break;
1431                 default:
1432                         chg_virtue(V_KNOWLEDGE, -10);
1433                         break;
1434                 }
1435
1436                 /* Damage CON (possibly permanently) */
1437                 if (randint0(100) < 50)
1438                 {
1439                         bool perm = (randint0(100) < 25);
1440
1441                         msg_print(_("体を悪くしてしまった！", "You have damaged your health!"));
1442
1443                         /* Reduce constitution */
1444                         (void)dec_stat(A_CON, 15 + randint1(10), perm);
1445                 }
1446         }
1447
1448         p_ptr->window |= (PW_PLAYER);
1449         p_ptr->window |= (PW_SPELL);
1450 }