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