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