src/cmd5.c

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