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