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(int tval)
  22 {
  23         switch (tval)
  24         {
  25 #ifdef JP
  26         case TV_HISSATSU_BOOK:
  27                 return "必殺技";
  28         case TV_LIFE_BOOK:
  29                 return "祈り";
  30         case TV_MUSIC_BOOK:
  31                 return "歌";
  32         default:
  33                 return "呪文";
  34 #else
  35         case TV_HISSATSU_BOOK:
  36                 return "art";
  37         case TV_LIFE_BOOK:
  38                 return "prayer";
  39         case TV_MUSIC_BOOK:
  40                 return "song";
  41         default:
  42                 return "spell";
  43 #endif
  44         }
  45 }
  46
  47
  48 bool select_the_force = FALSE;
  49
  50 /*!
  51  * @brief 領域魔法の閲覧、学習、使用選択するインターフェイス処理
  52  * Allow user to choose a spell/prayer from the given book.
  53  * @param sn 選択した魔法IDを返す参照ポインタ
  54  * @param prompt 魔法を利用する際の動詞表記
  55  * @param sval 魔道書のsval
  56  * @param learned 閲覧/使用選択ならばTRUE、学習処理ならFALSE
  57  * @param use_realm 魔法領域ID
  58  * @return
  59  * <pre>
  60  * If a valid spell is chosen, saves it in '*sn' and returns TRUE
  61  * If the user hits escape, returns FALSE, and set '*sn' to -1
  62  * If there are no legal choices, returns FALSE, and sets '*sn' to -2
  63  * The "prompt" should be "cast", "recite", or "study"
  64  * The "known" should be TRUE for cast/pray, FALSE for study
  65  * </pre>
  66  */
  67 static int get_spell(int *sn, cptr prompt, int sval, bool learned, int use_realm)
  68 {
  69         int         i;
  70         int         spell = -1;
  71         int         num = 0;
  72         int         ask = TRUE;
  73         int         need_mana;
  74         byte        spells[64];
  75         bool        flag, redraw, okay;
  76         char        choice;
  77         const magic_type  *s_ptr;
  78         char        out_val[160];
  79         cptr        p;
  80 #ifdef JP
  81         char jverb_buf[128];
  82 #endif
  83         int menu_line = (use_menu ? 1 : 0);
  84
  85 #ifdef ALLOW_REPEAT /* TNB */
  86
  87         /* Get the spell, if available */
  88         if (repeat_pull(sn))
  89         {
  90                 /* Verify the spell */
  91                 if (spell_okay(*sn, learned, FALSE, use_realm))
  92                 {
  93                         /* Success */
  94                         return (TRUE);
  95                 }
  96         }
  97
  98 #endif /* ALLOW_REPEAT -- TNB */
  99
 100         p = spell_category_name(mp_ptr->spell_book);
 101
 102         /* Extract spells */
 103         for (spell = 0; spell < 32; spell++)
 104         {
 105                 /* Check for this spell */
 106                 if ((fake_spell_flags[sval] & (1L << spell)))
 107                 {
 108                         /* Collect this spell */
 109                         spells[num++] = spell;
 110                 }
 111         }
 112
 113         /* Assume no usable spells */
 114         okay = FALSE;
 115
 116         /* Assume no spells available */
 117         (*sn) = -2;
 118
 119         /* Check for "okay" spells */
 120         for (i = 0; i < num; i++)
 121         {
 122                 /* Look for "okay" spells */
 123                 if (spell_okay(spells[i], learned, FALSE, use_realm)) okay = TRUE;
 124         }
 125
 126         /* No "okay" spells */
 127         if (!okay) return (FALSE);
 128         if (((use_realm) != p_ptr->realm1) && ((use_realm) != p_ptr->realm2) && (p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return FALSE;
 129         if (((p_ptr->pclass == CLASS_SORCERER) || (p_ptr->pclass == CLASS_RED_MAGE)) && !is_magic(use_realm)) return FALSE;
 130         if ((p_ptr->pclass == CLASS_RED_MAGE) && ((use_realm) != REALM_ARCANE) && (sval > 1)) return FALSE;
 131
 132         /* Assume cancelled */
 133         *sn = (-1);
 134
 135         /* Nothing chosen yet */
 136         flag = FALSE;
 137
 138         /* No redraw yet */
 139         redraw = FALSE;
 140
 141         /* Show choices */
 142         p_ptr->window |= (PW_SPELL);
 143
 144         /* Window stuff */
 145         window_stuff();
 146
 147         /* Build a prompt (accept all spells) */
 148 #ifdef JP
 149         jverb( prompt, jverb_buf, JVERB_AND );
 150         (void) strnfmt(out_val, 78, "(%^s:%c-%c, '*'で一覧, ESCで中断) どの%sを%^sますか? ",
 151                 p, I2A(0), I2A(num - 1), p, jverb_buf );
 152 #else
 153         (void)strnfmt(out_val, 78, "(%^ss %c-%c, *=List, ESC=exit) %^s which %s? ",
 154                 p, I2A(0), I2A(num - 1), prompt, p);
 155 #endif
 156
 157         /* Get a spell from the user */
 158
 159         choice = (always_show_list || use_menu) ? ESCAPE : 1;
 160         while (!flag)
 161         {
 162                 if (choice == ESCAPE) choice = ' ';
 163                 else if (!get_com(out_val, &choice, TRUE))break;
 164
 165                 if (use_menu && choice != ' ')
 166                 {
 167                         switch (choice)
 168                         {
 169                                 case '0':
 170                                 {
 171                                         screen_load();
 172                                         return FALSE;
 173                                 }
 174
 175                                 case '8':
 176                                 case 'k':
 177                                 case 'K':
 178                                 {
 179                                         menu_line += (num - 1);
 180                                         break;
 181                                 }
 182
 183                                 case '2':
 184                                 case 'j':
 185                                 case 'J':
 186                                 {
 187                                         menu_line++;
 188                                         break;
 189                                 }
 190
 191                                 case 'x':
 192                                 case 'X':
 193                                 case '\r':
 194                                 case '\n':
 195                                 {
 196                                         i = menu_line - 1;
 197                                         ask = FALSE;
 198                                         break;
 199                                 }
 200                         }
 201                         if (menu_line > num) menu_line -= num;
 202                         /* Display a list of spells */
 203                         print_spells(menu_line, spells, num, 1, 15, use_realm);
 204                         if (ask) continue;
 205                 }
 206                 else
 207                 {
 208                         /* Request redraw */
 209                         if ((choice == ' ') || (choice == '*') || (choice == '?'))
 210                         {
 211                                 /* Show the list */
 212                                 if (!redraw)
 213                                 {
 214                                         /* Show list */
 215                                         redraw = TRUE;
 216
 217                                         /* Save the screen */
 218                                         screen_save();
 219
 220                                         /* Display a list of spells */
 221                                         print_spells(menu_line, spells, num, 1, 15, use_realm);
 222                                 }
 223
 224                                 /* Hide the list */
 225                                 else
 226                                 {
 227                                         if (use_menu) continue;
 228
 229                                         /* Hide list */
 230                                         redraw = FALSE;
 231
 232                                         /* Restore the screen */
 233                                         screen_load();
 234                                 }
 235
 236                                 /* Redo asking */
 237                                 continue;
 238                         }
 239
 240
 241                         /* Note verify */
 242                         ask = (isupper(choice));
 243
 244                         /* Lowercase */
 245                         if (ask) choice = tolower(choice);
 246
 247                         /* Extract request */
 248                         i = (islower(choice) ? A2I(choice) : -1);
 249                 }
 250
 251                 /* Totally Illegal */
 252                 if ((i < 0) || (i >= num))
 253                 {
 254                         bell();
 255                         continue;
 256                 }
 257
 258                 /* Save the spell index */
 259                 spell = spells[i];
 260
 261                 /* Require "okay" spells */
 262                 if (!spell_okay(spell, learned, FALSE, use_realm))
 263                 {
 264                         bell();
 265 #ifdef JP
 266                         msg_format("その%sを%sことはできません。", p, prompt);
 267 #else
 268                         msg_format("You may not %s that %s.", prompt, p);
 269 #endif
 270
 271                         continue;
 272                 }
 273
 274                 /* Verify it */
 275                 if (ask)
 276                 {
 277                         char tmp_val[160];
 278
 279                         /* Access the spell */
 280                         if (!is_magic(use_realm))
 281                         {
 282                                 s_ptr = &technic_info[use_realm - MIN_TECHNIC][spell];
 283                         }
 284                         else
 285                         {
 286                                 s_ptr = &mp_ptr->info[use_realm - 1][spell];
 287                         }
 288
 289                         /* Extract mana consumption rate */
 290                         if (use_realm == REALM_HISSATSU)
 291                         {
 292                                 need_mana = s_ptr->smana;
 293                         }
 294                         else
 295                         {
 296                                 need_mana = mod_need_mana(s_ptr->smana, spell, use_realm);
 297                         }
 298
 299                         /* Prompt */
 300 #ifdef JP
 301                         jverb( prompt, jverb_buf, JVERB_AND );
 302                         /* 英日切り替え機能に対応 */
 303                         (void) strnfmt(tmp_val, 78, "%s(MP%d, 失敗率%d%%)を%sますか? ",
 304                                 do_spell(use_realm, spell, SPELL_NAME), need_mana,
 305                                        spell_chance(spell, use_realm),jverb_buf);
 306 #else
 307                         (void)strnfmt(tmp_val, 78, "%^s %s (%d mana, %d%% fail)? ",
 308                                 prompt, do_spell(use_realm, spell, SPELL_NAME), need_mana,
 309                                 spell_chance(spell, use_realm));
 310 #endif
 311
 312
 313                         /* Belay that order */
 314                         if (!get_check(tmp_val)) continue;
 315                 }
 316
 317                 /* Stop the loop */
 318                 flag = TRUE;
 319         }
 320
 321
 322         /* Restore the screen */
 323         if (redraw) screen_load();
 324
 325
 326         /* Show choices */
 327         p_ptr->window |= (PW_SPELL);
 328
 329         /* Window stuff */
 330         window_stuff();
 331
 332
 333         /* Abort if needed */
 334         if (!flag) return FALSE;
 335
 336         /* Save the choice */
 337         (*sn) = spell;
 338
 339 #ifdef ALLOW_REPEAT /* TNB */
 340
 341         repeat_push(*sn);
 342
 343 #endif /* ALLOW_REPEAT -- TNB */
 344
 345         /* Success */
 346         return TRUE;
 347 }
 348
 349 /*!
 350  * @brief オブジェクトがプレイヤーが使用可能な魔道書かどうかを判定する
 351  * @param o_ptr 判定したいオブ会ジェクトの構造体参照ポインタ
 352  * @return 学習できる魔道書ならばTRUEを返す
 353  */
 354 static bool item_tester_learn_spell(object_type *o_ptr)
 355 {
 356         s32b choices = realm_choices2[p_ptr->pclass];
 357
 358         if (p_ptr->pclass == CLASS_PRIEST)
 359         {
 360                 if (is_good_realm(p_ptr->realm1))
 361                 {
 362                         choices &= ~(CH_DEATH | CH_DAEMON);
 363                 }
 364                 else
 365                 {
 366                         choices &= ~(CH_LIFE | CH_CRUSADE);
 367                 }
 368         }
 369
 370         if ((o_ptr->tval < TV_LIFE_BOOK) || (o_ptr->tval > (TV_LIFE_BOOK + MAX_REALM - 1))) return (FALSE);
 371         if ((o_ptr->tval == TV_MUSIC_BOOK) && (p_ptr->pclass == CLASS_BARD)) return (TRUE);
 372         else if (!is_magic(tval2realm(o_ptr->tval))) return FALSE;
 373         if ((REALM1_BOOK == o_ptr->tval) || (REALM2_BOOK == o_ptr->tval)) return (TRUE);
 374         if (choices & (0x0001 << (tval2realm(o_ptr->tval) - 1))) return (TRUE);
 375         return (FALSE);
 376 }
 377
 378 /*!
 379  * @brief プレイヤーが魔道書を一冊も持っていないかを判定する
 380  * @return 魔道書を一冊も持っていないならTRUEを返す
 381  */
 382 static bool player_has_no_spellbooks(void)
 383 {
 384         int         i;
 385         object_type *o_ptr;
 386
 387         for (i = 0; i < INVEN_PACK; i++)
 388         {
 389                 o_ptr = &inventory[i];
 390                 if (o_ptr->k_idx && check_book_realm(o_ptr->tval, o_ptr->sval)) return FALSE;
 391         }
 392
 393         for (i = cave[py][px].o_idx; i; i = o_ptr->next_o_idx)
 394         {
 395                 o_ptr = &o_list[i];
 396                 if (o_ptr->k_idx && (o_ptr->marked & OM_FOUND) && check_book_realm(o_ptr->tval, o_ptr->sval)) return FALSE;
 397         }
 398
 399         return TRUE;
 400 }
 401
 402 /*!
 403  * @brief プレイヤーの職業が練気術師の時、領域魔法と練気術を切り換える処理のインターフェイス
 404  * @param browse_only 魔法と技能の閲覧を行うならばTRUE
 405  * @return 魔道書を一冊も持っていないならTRUEを返す
 406  */
 407 static void confirm_use_force(bool browse_only)
 408 {
 409         int  item;
 410         char which;
 411
 412 #ifdef ALLOW_REPEAT
 413
 414         /* Get the item index */
 415         if (repeat_pull(&item) && (item == INVEN_FORCE))
 416         {
 417                 browse_only ? do_cmd_mind_browse() : do_cmd_mind();
 418                 return;
 419         }
 420
 421 #endif /* ALLOW_REPEAT */
 422
 423         /* Show the prompt */
 424 #ifdef JP
 425         prt("('w'練気術, ESC) 'w'かESCを押してください。 ", 0, 0);
 426 #else
 427         prt("(w for the Force, ESC) Hit 'w' or ESC. ", 0, 0);
 428 #endif
 429
 430         while (1)
 431         {
 432                 /* Get a key */
 433                 which = inkey();
 434
 435                 if (which == ESCAPE) break;
 436                 else if (which == 'w')
 437                 {
 438
 439 #ifdef ALLOW_REPEAT
 440
 441                         repeat_push(INVEN_FORCE);
 442
 443 #endif /* ALLOW_REPEAT */
 444
 445                         break;
 446                 }
 447         }
 448
 449         /* Clear the prompt line */
 450         prt("", 0, 0);
 451
 452         if (which == 'w')
 453         {
 454                 browse_only ? do_cmd_mind_browse() : do_cmd_mind();
 455         }
 456 }
 457
 458
 459 /*!
 460  * @brief プレイヤーの魔法と技能を閲覧するコマンドのメインルーチン /
 461  * Peruse the spells/prayers in a book
 462  * @return なし
 463  * @details
 464  * <pre>
 465  * Note that *all* spells in the book are listed
 466  *
 467  * Note that browsing is allowed while confused or blind,
 468  * and in the dark, primarily to allow browsing in stores.
 469  * </pre>
 470  */
 471 void do_cmd_browse(void)
 472 {
 473         int             item, sval, use_realm = 0, j, line;
 474         int             spell = -1;
 475         int             num = 0;
 476
 477         byte            spells[64];
 478         char            temp[62*4];
 479
 480         object_type     *o_ptr;
 481
 482         cptr q, s;
 483
 484         /* Warriors are illiterate */
 485         if (!(p_ptr->realm1 || p_ptr->realm2) && (p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE))
 486         {
 487 #ifdef JP
 488                 msg_print("本を読むことができない！");
 489 #else
 490                 msg_print("You cannot read books!");
 491 #endif
 492
 493                 return;
 494         }
 495
 496         if (p_ptr->special_defense & KATA_MUSOU)
 497         {
 498                 set_action(ACTION_NONE);
 499         }
 500
 501         if (p_ptr->pclass == CLASS_FORCETRAINER)
 502         {
 503                 if (player_has_no_spellbooks())
 504                 {
 505                         confirm_use_force(TRUE);
 506                         return;
 507                 }
 508                 select_the_force = TRUE;
 509         }
 510
 511         /* Restrict choices to "useful" books */
 512         if (p_ptr->realm2 == REALM_NONE) item_tester_tval = mp_ptr->spell_book;
 513         else item_tester_hook = item_tester_learn_spell;
 514
 515         /* Get an item */
 516 #ifdef JP
 517         q = "どの本を読みますか? ";
 518 #else
 519         q = "Browse which book? ";
 520 #endif
 521
 522 #ifdef JP
 523         s = "読める本がない。";
 524 #else
 525         s = "You have no books that you can read.";
 526 #endif
 527
 528         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR)))
 529         {
 530                 select_the_force = FALSE;
 531                 return;
 532         }
 533         select_the_force = FALSE;
 534
 535         if (item == INVEN_FORCE) /* the_force */
 536         {
 537                 do_cmd_mind_browse();
 538                 return;
 539         }
 540
 541         /* Get the item (in the pack) */
 542         else if (item >= 0)
 543         {
 544                 o_ptr = &inventory[item];
 545         }
 546
 547         /* Get the item (on the floor) */
 548         else
 549         {
 550                 o_ptr = &o_list[0 - item];
 551         }
 552
 553         /* Access the item's sval */
 554         sval = o_ptr->sval;
 555
 556         use_realm = tval2realm(o_ptr->tval);
 557
 558         /* Track the object kind */
 559         object_kind_track(o_ptr->k_idx);
 560
 561         /* Hack -- Handle stuff */
 562         handle_stuff();
 563
 564
 565         /* Extract spells */
 566         for (spell = 0; spell < 32; spell++)
 567         {
 568                 /* Check for this spell */
 569                 if ((fake_spell_flags[sval] & (1L << spell)))
 570                 {
 571                         /* Collect this spell */
 572                         spells[num++] = spell;
 573                 }
 574         }
 575
 576
 577         /* Save the screen */
 578         screen_save();
 579
 580         /* Clear the top line */
 581         prt("", 0, 0);
 582
 583         /* Keep browsing spells.  Exit browsing on cancel. */
 584         while(TRUE)
 585         {
 586                 /* Ask for a spell, allow cancel */
 587 #ifdef JP
 588                 if (!get_spell(&spell, "読む", o_ptr->sval, TRUE, use_realm))
 589 #else
 590                 if (!get_spell(&spell, "browse", o_ptr->sval, TRUE, use_realm))
 591 #endif
 592                 {
 593                         /* If cancelled, leave immediately. */
 594                         if (spell == -1) break;
 595
 596                         /* Display a list of spells */
 597                         print_spells(0, spells, num, 1, 15, use_realm);
 598
 599                         /* Notify that there's nothing to see, and wait. */
 600                         if (use_realm == REALM_HISSATSU)
 601 #ifdef JP
 602                                 prt("読める技がない。", 0, 0);
 603 #else
 604                                 prt("No techniques to browse.", 0, 0);
 605 #endif
 606                         else
 607 #ifdef JP
 608                                 prt("読める呪文がない。", 0, 0);
 609 #else
 610                                 prt("No spells to browse.", 0, 0);
 611 #endif
 612                         (void)inkey();
 613
 614
 615                         /* Restore the screen */
 616                         screen_load();
 617
 618                         return;
 619                 }
 620
 621                 /* Clear lines, position cursor  (really should use strlen here) */
 622                 Term_erase(14, 14, 255);
 623                 Term_erase(14, 13, 255);
 624                 Term_erase(14, 12, 255);
 625                 Term_erase(14, 11, 255);
 626
 627                 roff_to_buf(do_spell(use_realm, spell, SPELL_DESC), 62, temp, sizeof(temp));
 628
 629                 for (j = 0, line = 11; temp[j]; j += 1 + strlen(&temp[j]))
 630                 {
 631                         prt(&temp[j], line, 15);
 632                         line++;
 633                 }
 634         }
 635
 636         /* Restore the screen */
 637         screen_load();
 638 }
 639
 640 /*!
 641  * @brief プレイヤーの第二魔法領域を変更する /
 642  * @param next_realm 変更先の魔法領域ID
 643  * @return なし
 644  */
 645 static void change_realm2(int next_realm)
 646 {
 647         int i, j = 0;
 648         char tmp[80];
 649
 650         for (i = 0; i < 64; i++)
 651         {
 652                 p_ptr->spell_order[j] = p_ptr->spell_order[i];
 653                 if (p_ptr->spell_order[i] < 32) j++;
 654         }
 655         for (; j < 64; j++)
 656                 p_ptr->spell_order[j] = 99;
 657
 658         for (i = 32; i < 64; i++)
 659         {
 660                 p_ptr->spell_exp[i] = SPELL_EXP_UNSKILLED;
 661         }
 662         p_ptr->spell_learned2 = 0L;
 663         p_ptr->spell_worked2 = 0L;
 664         p_ptr->spell_forgotten2 = 0L;
 665
 666 #ifdef JP
 667         sprintf(tmp,"魔法の領域を%sから%sに変更した。", realm_names[p_ptr->realm2], realm_names[next_realm]);
 668 #else
 669         sprintf(tmp,"change magic realm from %s to %s.", realm_names[p_ptr->realm2], realm_names[next_realm]);
 670 #endif
 671         do_cmd_write_nikki(NIKKI_BUNSHOU, 0, tmp);
 672         p_ptr->old_realm |= 1 << (p_ptr->realm2-1);
 673         p_ptr->realm2 = next_realm;
 674
 675         p_ptr->notice |= (PN_REORDER);
 676         p_ptr->update |= (PU_SPELLS);
 677         handle_stuff();
 678
 679         /* Load an autopick preference file */
 680         autopick_load_pref(FALSE);
 681 }
 682
 683
 684 /*!
 685  * @brief 魔法を学習するコマンドのメインルーチン /
 686  * Study a book to gain a new spell/prayer
 687  * @return なし
 688  */
 689 void do_cmd_study(void)
 690 {
 691         int     i, item, sval;
 692         int     increment = 0;
 693         bool    learned = FALSE;
 694
 695         /* Spells of realm2 will have an increment of +32 */
 696         int     spell = -1;
 697
 698         cptr p = spell_category_name(mp_ptr->spell_book);
 699
 700         object_type *o_ptr;
 701
 702         cptr q, s;
 703
 704         if (!p_ptr->realm1)
 705         {
 706 #ifdef JP
 707 msg_print("本を読むことができない！");
 708 #else
 709                 msg_print("You cannot read books!");
 710 #endif
 711
 712                 return;
 713         }
 714
 715         if (p_ptr->blind || no_lite())
 716         {
 717 #ifdef JP
 718 msg_print("目が見えない！");
 719 #else
 720                 msg_print("You cannot see!");
 721 #endif
 722
 723                 return;
 724         }
 725
 726         if (p_ptr->confused)
 727         {
 728 #ifdef JP
 729 msg_print("混乱していて読めない！");
 730 #else
 731                 msg_print("You are too confused!");
 732 #endif
 733
 734                 return;
 735         }
 736
 737         if (!(p_ptr->new_spells))
 738         {
 739 #ifdef JP
 740 msg_format("新しい%sを覚えることはできない！", p);
 741 #else
 742                 msg_format("You cannot learn any new %ss!", p);
 743 #endif
 744
 745                 return;
 746         }
 747
 748         if (p_ptr->special_defense & KATA_MUSOU)
 749         {
 750                 set_action(ACTION_NONE);
 751         }
 752
 753 #ifdef JP
 754         if( p_ptr->new_spells < 10 ){
 755                 msg_format("あと %d つの%sを学べる。", p_ptr->new_spells, p);
 756         }else{
 757                 msg_format("あと %d 個の%sを学べる。", p_ptr->new_spells, p);
 758         }
 759 #else
 760         msg_format("You can learn %d new %s%s.", p_ptr->new_spells, p,
 761                 (p_ptr->new_spells == 1?"":"s"));
 762 #endif
 763
 764         msg_print(NULL);
 765
 766
 767         /* Restrict choices to "useful" books */
 768         if (p_ptr->realm2 == REALM_NONE) item_tester_tval = mp_ptr->spell_book;
 769         else item_tester_hook = item_tester_learn_spell;
 770
 771         /* Get an item */
 772 #ifdef JP
 773 q = "どの本から学びますか? ";
 774 #else
 775         q = "Study which book? ";
 776 #endif
 777
 778 #ifdef JP
 779 s = "読める本がない。";
 780 #else
 781         s = "You have no books that you can read.";
 782 #endif
 783
 784         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
 785
 786         /* Get the item (in the pack) */
 787         if (item >= 0)
 788         {
 789                 o_ptr = &inventory[item];
 790         }
 791
 792         /* Get the item (on the floor) */
 793         else
 794         {
 795                 o_ptr = &o_list[0 - item];
 796         }
 797
 798         /* Access the item's sval */
 799         sval = o_ptr->sval;
 800
 801         if (o_ptr->tval == REALM2_BOOK) increment = 32;
 802         else if (o_ptr->tval != REALM1_BOOK)
 803         {
 804 #ifdef JP
 805                 if (!get_check("本当に魔法の領域を変更しますか？")) return;
 806 #else
 807                 if (!get_check("Really, change magic realm? ")) return;
 808 #endif
 809                 change_realm2(tval2realm(o_ptr->tval));
 810                 increment = 32;
 811         }
 812
 813         /* Track the object kind */
 814         object_kind_track(o_ptr->k_idx);
 815
 816         /* Hack -- Handle stuff */
 817         handle_stuff();
 818
 819         /* Mage -- Learn a selected spell */
 820         if (mp_ptr->spell_book != TV_LIFE_BOOK)
 821         {
 822                 /* Ask for a spell, allow cancel */
 823 #ifdef JP
 824                 if (!get_spell(&spell, "学ぶ", sval, FALSE, o_ptr->tval - TV_LIFE_BOOK + 1)
 825                         && (spell == -1)) return;
 826 #else
 827                 if (!get_spell(&spell, "study", sval, FALSE, o_ptr->tval - TV_LIFE_BOOK + 1)
 828                         && (spell == -1)) return;
 829 #endif
 830
 831         }
 832
 833         /* Priest -- Learn a random prayer */
 834         else
 835         {
 836                 int k = 0;
 837
 838                 int gift = -1;
 839
 840                 /* Extract spells */
 841                 for (spell = 0; spell < 32; spell++)
 842                 {
 843                         /* Check spells in the book */
 844                         if ((fake_spell_flags[sval] & (1L << spell)))
 845                         {
 846                                 /* Skip non "okay" prayers */
 847                                 if (!spell_okay(spell, FALSE, TRUE,
 848                                         (increment ? p_ptr->realm2 : p_ptr->realm1))) continue;
 849
 850                                 /* Hack -- Prepare the randomizer */
 851                                 k++;
 852
 853                                 /* Hack -- Apply the randomizer */
 854                                 if (one_in_(k)) gift = spell;
 855                         }
 856                 }
 857
 858                 /* Accept gift */
 859                 spell = gift;
 860         }
 861
 862         /* Nothing to study */
 863         if (spell < 0)
 864         {
 865                 /* Message */
 866 #ifdef JP
 867 msg_format("その本には学ぶべき%sがない。", p);
 868 #else
 869                 msg_format("You cannot learn any %ss in that book.", p);
 870 #endif
 871
 872
 873                 /* Abort */
 874                 return;
 875         }
 876
 877
 878         if (increment) spell += increment;
 879
 880         /* Learn the spell */
 881         if (spell < 32)
 882         {
 883                 if (p_ptr->spell_learned1 & (1L << spell)) learned = TRUE;
 884                 else p_ptr->spell_learned1 |= (1L << spell);
 885         }
 886         else
 887         {
 888                 if (p_ptr->spell_learned2 & (1L << (spell - 32))) learned = TRUE;
 889                 else p_ptr->spell_learned2 |= (1L << (spell - 32));
 890         }
 891
 892         if (learned)
 893         {
 894                 int max_exp = (spell < 32) ? SPELL_EXP_MASTER : SPELL_EXP_EXPERT;
 895                 int old_exp = p_ptr->spell_exp[spell];
 896                 int new_rank = EXP_LEVEL_UNSKILLED;
 897                 cptr name = do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell%32, SPELL_NAME);
 898
 899                 if (old_exp >= max_exp)
 900                 {
 901 #ifdef JP
 902                         msg_format("その%sは完全に使いこなせるので学ぶ必要はない。", p);
 903 #else
 904                         msg_format("You don't need to study this %s anymore.", p);
 905 #endif
 906                         return;
 907                 }
 908 #ifdef JP
 909                 if (!get_check(format("%sの%sをさらに学びます。よろしいですか？", name, p)))
 910 #else
 911                 if (!get_check(format("You will study a %s of %s again. Are you sure? ", p, name)))
 912 #endif
 913                 {
 914                         return;
 915                 }
 916                 else if (old_exp >= SPELL_EXP_EXPERT)
 917                 {
 918                         p_ptr->spell_exp[spell] = SPELL_EXP_MASTER;
 919                         new_rank = EXP_LEVEL_MASTER;
 920                 }
 921                 else if (old_exp >= SPELL_EXP_SKILLED)
 922                 {
 923                         if (spell >= 32) p_ptr->spell_exp[spell] = SPELL_EXP_EXPERT;
 924                         else p_ptr->spell_exp[spell] += SPELL_EXP_EXPERT - SPELL_EXP_SKILLED;
 925                         new_rank = EXP_LEVEL_EXPERT;
 926                 }
 927                 else if (old_exp >= SPELL_EXP_BEGINNER)
 928                 {
 929                         p_ptr->spell_exp[spell] = SPELL_EXP_SKILLED + (old_exp - SPELL_EXP_BEGINNER) * 2 / 3;
 930                         new_rank = EXP_LEVEL_SKILLED;
 931                 }
 932                 else
 933                 {
 934                         p_ptr->spell_exp[spell] = SPELL_EXP_BEGINNER + old_exp / 3;
 935                         new_rank = EXP_LEVEL_BEGINNER;
 936                 }
 937 #ifdef JP
 938                 msg_format("%sの熟練度が%sに上がった。", name, exp_level_str[new_rank]);
 939 #else
 940                 msg_format("Your proficiency of %s is now %s rank.", name, exp_level_str[new_rank]);
 941 #endif
 942         }
 943         else
 944         {
 945                 /* Find the next open entry in "p_ptr->spell_order[]" */
 946                 for (i = 0; i < 64; i++)
 947                 {
 948                         /* Stop at the first empty space */
 949                         if (p_ptr->spell_order[i] == 99) break;
 950                 }
 951
 952                 /* Add the spell to the known list */
 953                 p_ptr->spell_order[i++] = spell;
 954
 955                 /* Mention the result */
 956 #ifdef JP
 957                 /* 英日切り替え機能に対応 */
 958                 if (mp_ptr->spell_book == TV_MUSIC_BOOK)
 959                 {
 960                         msg_format("%sを学んだ。",
 961                                     do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell % 32, SPELL_NAME));
 962                 }
 963                 else
 964                 {
 965                         msg_format("%sの%sを学んだ。",
 966                                     do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell % 32, SPELL_NAME) ,p);
 967                 }
 968 #else
 969                 msg_format("You have learned the %s of %s.",
 970                         p, do_spell(increment ? p_ptr->realm2 : p_ptr->realm1, spell % 32, SPELL_NAME));
 971 #endif
 972         }
 973
 974         /* Take a turn */
 975         energy_use = 100;
 976
 977         switch (mp_ptr->spell_book)
 978         {
 979         case TV_LIFE_BOOK:
 980                 chg_virtue(V_FAITH, 1);
 981                 break;
 982         case TV_DEATH_BOOK:
 983                 chg_virtue(V_UNLIFE, 1);
 984                 break;
 985         case TV_NATURE_BOOK:
 986                 chg_virtue(V_NATURE, 1);
 987                 break;
 988         default:
 989                 chg_virtue(V_KNOWLEDGE, 1);
 990                 break;
 991         }
 992
 993         /* Sound */
 994         sound(SOUND_STUDY);
 995
 996         /* One less spell available */
 997         p_ptr->learned_spells++;
 998 #if 0
 999         /* Message if needed */
1000         if (p_ptr->new_spells)
1001         {
1002                 /* Message */
1003 #ifdef JP
1004                 if (p_ptr->new_spells < 10) msg_format("あと %d つの%sを学べる。", p_ptr->new_spells, p);
1005                 else msg_format("あと %d 個の%sを学べる。", p_ptr->new_spells, p);
1006 #else
1007                 msg_format("You can learn %d more %s%s.", p_ptr->new_spells, p,
1008                            (p_ptr->new_spells != 1) ? "s" : "");
1009 #endif
1010         }
1011 #endif
1012
1013         /* Update Study */
1014         p_ptr->update |= (PU_SPELLS);
1015         update_stuff();
1016
1017         /* Redraw object recall */
1018         p_ptr->window |= (PW_OBJECT);
1019 }
1020
1021 /*!
1022  * @brief 運命の輪、並びにカオス的な効果の発動
1023  * @param spell ランダムな効果を選択するための基準ID
1024  * @return なし
1025  */
1026 static void wild_magic(int spell)
1027 {
1028         int counter = 0;
1029         int type = SUMMON_BIZARRE1 + randint0(6);
1030
1031         if (type < SUMMON_BIZARRE1) type = SUMMON_BIZARRE1;
1032         else if (type > SUMMON_BIZARRE6) type = SUMMON_BIZARRE6;
1033
1034         switch (randint1(spell) + randint1(8) + 1)
1035         {
1036         case 1:
1037         case 2:
1038         case 3:
1039                 teleport_player(10, TELEPORT_PASSIVE);
1040                 break;
1041         case 4:
1042         case 5:
1043         case 6:
1044                 teleport_player(100, TELEPORT_PASSIVE);
1045                 break;
1046         case 7:
1047         case 8:
1048                 teleport_player(200, TELEPORT_PASSIVE);
1049                 break;
1050         case 9:
1051         case 10:
1052         case 11:
1053                 unlite_area(10, 3);
1054                 break;
1055         case 12:
1056         case 13:
1057         case 14:
1058                 lite_area(damroll(2, 3), 2);
1059                 break;
1060         case 15:
1061                 destroy_doors_touch();
1062                 break;
1063         case 16: case 17:
1064                 wall_breaker();
1065         case 18:
1066                 sleep_monsters_touch();
1067                 break;
1068         case 19:
1069         case 20:
1070                 trap_creation(py, px);
1071                 break;
1072         case 21:
1073         case 22:
1074                 door_creation();
1075                 break;
1076         case 23:
1077         case 24:
1078         case 25:
1079                 aggravate_monsters(0);
1080                 break;
1081         case 26:
1082                 earthquake(py, px, 5);
1083                 break;
1084         case 27:
1085         case 28:
1086                 (void)gain_random_mutation(0);
1087                 break;
1088         case 29:
1089         case 30:
1090                 apply_disenchant(1);
1091                 break;
1092         case 31:
1093                 lose_all_info();
1094                 break;
1095         case 32:
1096                 fire_ball(GF_CHAOS, 0, spell + 5, 1 + (spell / 10));
1097                 break;
1098         case 33:
1099                 wall_stone();
1100                 break;
1101         case 34:
1102         case 35:
1103                 while (counter++ < 8)
1104                 {
1105                         (void)summon_specific(0, py, px, (dun_level * 3) / 2, type, (PM_ALLOW_GROUP | PM_NO_PET));
1106                 }
1107                 break;
1108         case 36:
1109         case 37:
1110                 activate_hi_summon(py, px, FALSE);
1111                 break;
1112         case 38:
1113                 (void)summon_cyber(-1, py, px);
1114                 break;
1115         default:
1116                 {
1117                         int count = 0;
1118                         (void)activate_ty_curse(FALSE, &count);
1119                         break;
1120                 }
1121         }
1122
1123         return;
1124 }
1125
1126
1127 /*!
1128  * @brief 魔法を詠唱するコマンドのメインルーチン /
1129  * Cast a spell
1130  * @return なし
1131  */
1132 void do_cmd_cast(void)
1133 {
1134         int     item, sval, spell, realm;
1135         int     chance;
1136         int     increment = 0;
1137         int     use_realm;
1138         int     need_mana;
1139
1140         cptr prayer;
1141
1142         object_type     *o_ptr;
1143
1144         const magic_type *s_ptr;
1145
1146         cptr q, s;
1147
1148         bool over_exerted = FALSE;
1149
1150         /* Require spell ability */
1151         if (!p_ptr->realm1 && (p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE))
1152         {
1153 #ifdef JP
1154                 msg_print("呪文を唱えられない！");
1155 #else
1156                 msg_print("You cannot cast spells!");
1157 #endif
1158
1159                 return;
1160         }
1161
1162         /* Require lite */
1163         if (p_ptr->blind || no_lite())
1164         {
1165                 if (p_ptr->pclass == CLASS_FORCETRAINER) confirm_use_force(FALSE);
1166                 else
1167                 {
1168 #ifdef JP
1169                         msg_print("目が見えない！");
1170 #else
1171                         msg_print("You cannot see!");
1172 #endif
1173                         flush();
1174                 }
1175                 return;
1176         }
1177
1178         /* Not when confused */
1179         if (p_ptr->confused)
1180         {
1181 #ifdef JP
1182                 msg_print("混乱していて唱えられない！");
1183 #else
1184                 msg_print("You are too confused!");
1185 #endif
1186                 flush();
1187                 return;
1188         }
1189
1190         /* Hex */
1191         if (p_ptr->realm1 == REALM_HEX)
1192         {
1193                 if (hex_spell_fully())
1194                 {
1195                         bool flag = FALSE;
1196 #ifdef JP
1197                         msg_print("これ以上新しい呪文を詠唱することはできない。");
1198 #else
1199                         msg_print("Can not spell new spells more.");
1200 #endif
1201                         flush();
1202                         if (p_ptr->lev >= 35) flag = stop_hex_spell();
1203                         if (!flag) return;
1204                 }
1205         }
1206
1207         if (p_ptr->pclass == CLASS_FORCETRAINER)
1208         {
1209                 if (player_has_no_spellbooks())
1210                 {
1211                         confirm_use_force(FALSE);
1212                         return;
1213                 }
1214                 select_the_force = TRUE;
1215         }
1216
1217         prayer = spell_category_name(mp_ptr->spell_book);
1218
1219         /* Restrict choices to spell books */
1220         item_tester_tval = mp_ptr->spell_book;
1221
1222         /* Get an item */
1223 #ifdef JP
1224         q = "どの呪文書を使いますか? ";
1225 #else
1226         q = "Use which book? ";
1227 #endif
1228
1229 #ifdef JP
1230         s = "呪文書がない！";
1231 #else
1232         s = "You have no spell books!";
1233 #endif
1234
1235         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR)))
1236         {
1237                 select_the_force = FALSE;
1238                 return;
1239         }
1240         select_the_force = FALSE;
1241
1242         if (item == INVEN_FORCE) /* the_force */
1243         {
1244                 do_cmd_mind();
1245                 return;
1246         }
1247
1248         /* Get the item (in the pack) */
1249         else if (item >= 0)
1250         {
1251                 o_ptr = &inventory[item];
1252         }
1253
1254         /* Get the item (on the floor) */
1255         else
1256         {
1257                 o_ptr = &o_list[0 - item];
1258         }
1259
1260         /* Access the item's sval */
1261         sval = o_ptr->sval;
1262
1263         if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE) && (o_ptr->tval == REALM2_BOOK)) increment = 32;
1264
1265
1266         /* Track the object kind */
1267         object_kind_track(o_ptr->k_idx);
1268
1269         /* Hack -- Handle stuff */
1270         handle_stuff();
1271
1272         if ((p_ptr->pclass == CLASS_SORCERER) || (p_ptr->pclass == CLASS_RED_MAGE))
1273                 realm = o_ptr->tval - TV_LIFE_BOOK + 1;
1274         else if (increment) realm = p_ptr->realm2;
1275         else realm = p_ptr->realm1;
1276
1277         /* Ask for a spell */
1278 #ifdef JP
1279         if (!get_spell(&spell,
1280                                 ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "詠唱する" : (mp_ptr->spell_book == TV_MUSIC_BOOK) ? "歌う" : "唱える"),
1281                        sval, TRUE, realm))
1282         {
1283                 if (spell == -2) msg_format("その本には知っている%sがない。", prayer);
1284                 return;
1285         }
1286 #else
1287         if (!get_spell(&spell, ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "recite" : "cast"),
1288                 sval, TRUE, realm))
1289         {
1290                 if (spell == -2)
1291                         msg_format("You don't know any %ss in that book.", prayer);
1292                 return;
1293         }
1294 #endif
1295
1296
1297         use_realm = tval2realm(o_ptr->tval);
1298
1299         /* Hex */
1300         if (use_realm == REALM_HEX)
1301         {
1302                 if (hex_spelling(spell))
1303                 {
1304 #ifdef JP
1305                         msg_print("その呪文はすでに詠唱中だ。");
1306 #else
1307                         msg_print("You are already casting it.");
1308 #endif
1309                         return;
1310                 }
1311         }
1312
1313         if (!is_magic(use_realm))
1314         {
1315                 s_ptr = &technic_info[use_realm - MIN_TECHNIC][spell];
1316         }
1317         else
1318         {
1319                 s_ptr = &mp_ptr->info[realm - 1][spell];
1320         }
1321
1322         /* Extract mana consumption rate */
1323         need_mana = mod_need_mana(s_ptr->smana, spell, realm);
1324
1325         /* Verify "dangerous" spells */
1326         if (need_mana > p_ptr->csp)
1327         {
1328                 if (flush_failure) flush();
1329
1330                 /* Warning */
1331 #ifdef JP
1332 msg_format("その%sを%sのに十分なマジックポイントがない。",prayer,
1333  ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "詠唱する" : (mp_ptr->spell_book == TV_LIFE_BOOK) ? "歌う" : "唱える"));
1334 #else
1335                 msg_format("You do not have enough mana to %s this %s.",
1336                         ((mp_ptr->spell_book == TV_LIFE_BOOK) ? "recite" : "cast"),
1337                         prayer);
1338 #endif
1339
1340
1341                 if (!over_exert) return;
1342
1343                 /* Verify */
1344 #ifdef JP
1345                 if (!get_check_strict("それでも挑戦しますか? ", CHECK_OKAY_CANCEL)) return;
1346 #else
1347                 if (!get_check_strict("Attempt it anyway? ", CHECK_OKAY_CANCEL)) return;
1348 #endif
1349
1350         }
1351
1352         /* Spell failure chance */
1353         chance = spell_chance(spell, use_realm);
1354
1355         /* Sufficient mana */
1356         if (need_mana <= p_ptr->csp)
1357         {
1358                 /* Use some mana */
1359                 p_ptr->csp -= need_mana;
1360         }
1361         else over_exerted = TRUE;
1362
1363         /* Redraw mana */
1364         p_ptr->redraw |= (PR_MANA);
1365
1366         /* Failed spell */
1367         if (randint0(100) < chance)
1368         {
1369                 if (flush_failure) flush();
1370
1371 #ifdef JP
1372 msg_format("%sをうまく唱えられなかった！", prayer);
1373 #else
1374                 msg_format("You failed to get the %s off!", prayer);
1375 #endif
1376
1377                 sound(SOUND_FAIL);
1378
1379                 switch (realm)
1380                 {
1381                 case REALM_LIFE:
1382                         if (randint1(100) < chance) chg_virtue(V_VITALITY, -1);
1383                         break;
1384                 case REALM_DEATH:
1385                         if (randint1(100) < chance) chg_virtue(V_UNLIFE, -1);
1386                         break;
1387                 case REALM_NATURE:
1388                         if (randint1(100) < chance) chg_virtue(V_NATURE, -1);
1389                         break;
1390                 case REALM_DAEMON:
1391                         if (randint1(100) < chance) chg_virtue(V_JUSTICE, 1);
1392                         break;
1393                 case REALM_CRUSADE:
1394                         if (randint1(100) < chance) chg_virtue(V_JUSTICE, -1);
1395                         break;
1396                 case REALM_HEX:
1397                         if (randint1(100) < chance) chg_virtue(V_COMPASSION, -1);
1398                         break;
1399                 default:
1400                         if (randint1(100) < chance) chg_virtue(V_KNOWLEDGE, -1);
1401                         break;
1402                 }
1403
1404                 /* Failure casting may activate some side effect */
1405                 do_spell(realm, spell, SPELL_FAIL);
1406
1407
1408                 if ((o_ptr->tval == TV_CHAOS_BOOK) && (randint1(100) < spell))
1409                 {
1410 #ifdef JP
1411 msg_print("カオス的な効果を発生した！");
1412 #else
1413                         msg_print("You produce a chaotic effect!");
1414 #endif
1415
1416                         wild_magic(spell);
1417                 }
1418                 else if ((o_ptr->tval == TV_DEATH_BOOK) && (randint1(100) < spell))
1419                 {
1420                         if ((sval == 3) && one_in_(2))
1421                         {
1422                                 sanity_blast(0, TRUE);
1423                         }
1424                         else
1425                         {
1426 #ifdef JP
1427                                 msg_print("痛い！");
1428 #else
1429                                 msg_print("It hurts!");
1430 #endif
1431
1432 #ifdef JP
1433                                 take_hit(DAMAGE_LOSELIFE, damroll(o_ptr->sval + 1, 6), "暗黒魔法の逆流", -1);
1434 #else
1435                                 take_hit(DAMAGE_LOSELIFE, damroll(o_ptr->sval + 1, 6), "a miscast Death spell", -1);
1436 #endif
1437
1438                                 if ((spell > 15) && one_in_(6) && !p_ptr->hold_exp)
1439                                         lose_exp(spell * 250);
1440                         }
1441                 }
1442                 else if ((o_ptr->tval == TV_MUSIC_BOOK) && (randint1(200) < spell))
1443                 {
1444 #ifdef JP
1445 msg_print("いやな音が響いた");
1446 #else
1447 msg_print("An infernal sound echoed.");
1448 #endif
1449
1450                         aggravate_monsters(0);
1451                 }
1452                 if (randint1(100) >= chance)
1453                         chg_virtue(V_CHANCE,-1);
1454         }
1455
1456         /* Process spell */
1457         else
1458         {
1459                 /* Canceled spells cost neither a turn nor mana */
1460                 if (!do_spell(realm, spell, SPELL_CAST)) return;
1461
1462                 if (randint1(100) < chance)
1463                         chg_virtue(V_CHANCE,1);
1464
1465                 /* A spell was cast */
1466                 if (!(increment ?
1467                     (p_ptr->spell_worked2 & (1L << spell)) :
1468                     (p_ptr->spell_worked1 & (1L << spell)))
1469                     && (p_ptr->pclass != CLASS_SORCERER)
1470                     && (p_ptr->pclass != CLASS_RED_MAGE))
1471                 {
1472                         int e = s_ptr->sexp;
1473
1474                         /* The spell worked */
1475                         if (realm == p_ptr->realm1)
1476                         {
1477                                 p_ptr->spell_worked1 |= (1L << spell);
1478                         }
1479                         else
1480                         {
1481                                 p_ptr->spell_worked2 |= (1L << spell);
1482                         }
1483
1484                         /* Gain experience */
1485                         gain_exp(e * s_ptr->slevel);
1486
1487                         /* Redraw object recall */
1488                         p_ptr->window |= (PW_OBJECT);
1489
1490                         switch (realm)
1491                         {
1492                         case REALM_LIFE:
1493                                 chg_virtue(V_TEMPERANCE, 1);
1494                                 chg_virtue(V_COMPASSION, 1);
1495                                 chg_virtue(V_VITALITY, 1);
1496                                 chg_virtue(V_DILIGENCE, 1);
1497                                 break;
1498                         case REALM_DEATH:
1499                                 chg_virtue(V_UNLIFE, 1);
1500                                 chg_virtue(V_JUSTICE, -1);
1501                                 chg_virtue(V_FAITH, -1);
1502                                 chg_virtue(V_VITALITY, -1);
1503                                 break;
1504                         case REALM_DAEMON:
1505                                 chg_virtue(V_JUSTICE, -1);
1506                                 chg_virtue(V_FAITH, -1);
1507                                 chg_virtue(V_HONOUR, -1);
1508                                 chg_virtue(V_TEMPERANCE, -1);
1509                                 break;
1510                         case REALM_CRUSADE:
1511                                 chg_virtue(V_FAITH, 1);
1512                                 chg_virtue(V_JUSTICE, 1);
1513                                 chg_virtue(V_SACRIFICE, 1);
1514                                 chg_virtue(V_HONOUR, 1);
1515                                 break;
1516                         case REALM_NATURE:
1517                                 chg_virtue(V_NATURE, 1);
1518                                 chg_virtue(V_HARMONY, 1);
1519                                 break;
1520                         case REALM_HEX:
1521                                 chg_virtue(V_JUSTICE, -1);
1522                                 chg_virtue(V_FAITH, -1);
1523                                 chg_virtue(V_HONOUR, -1);
1524                                 chg_virtue(V_COMPASSION, -1);
1525                                 break;
1526                         default:
1527                                 chg_virtue(V_KNOWLEDGE, 1);
1528                                 break;
1529                         }
1530                 }
1531                 switch (realm)
1532                 {
1533                 case REALM_LIFE:
1534                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_TEMPERANCE, 1);
1535                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_COMPASSION, 1);
1536                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_VITALITY, 1);
1537                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_DILIGENCE, 1);
1538                         break;
1539                 case REALM_DEATH:
1540                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_UNLIFE, 1);
1541                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, -1);
1542                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, -1);
1543                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_VITALITY, -1);
1544                         break;
1545                 case REALM_DAEMON:
1546                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, -1);
1547                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, -1);
1548                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HONOUR, -1);
1549                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_TEMPERANCE, -1);
1550                         break;
1551                 case REALM_CRUSADE:
1552                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, 1);
1553                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, 1);
1554                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_SACRIFICE, 1);
1555                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HONOUR, 1);
1556                         break;
1557                 case REALM_NATURE:
1558                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_NATURE, 1);
1559                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HARMONY, 1);
1560                         break;
1561                 case REALM_HEX:
1562                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_JUSTICE, -1);
1563                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_FAITH, -1);
1564                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_HONOUR, -1);
1565                         if (randint1(100 + p_ptr->lev) < need_mana) chg_virtue(V_COMPASSION, -1);
1566                         break;
1567                 }
1568                 if (mp_ptr->spell_xtra & MAGIC_GAIN_EXP)
1569                 {
1570                         s16b cur_exp = p_ptr->spell_exp[(increment ? 32 : 0)+spell];
1571                         s16b exp_gain = 0;
1572
1573                         if (cur_exp < SPELL_EXP_BEGINNER)
1574                                 exp_gain += 60;
1575                         else if (cur_exp < SPELL_EXP_SKILLED)
1576                         {
1577                                 if ((dun_level > 4) && ((dun_level + 10) > p_ptr->lev))
1578                                         exp_gain = 8;
1579                         }
1580                         else if (cur_exp < SPELL_EXP_EXPERT)
1581                         {
1582                                 if (((dun_level + 5) > p_ptr->lev) && ((dun_level + 5) > s_ptr->slevel))
1583                                         exp_gain = 2;
1584                         }
1585                         else if ((cur_exp < SPELL_EXP_MASTER) && !increment)
1586                         {
1587                                 if (((dun_level + 5) > p_ptr->lev) && (dun_level > s_ptr->slevel))
1588                                         exp_gain = 1;
1589                         }
1590                         p_ptr->spell_exp[(increment ? 32 : 0) + spell] += exp_gain;
1591                 }
1592         }
1593
1594         /* Take a turn */
1595         energy_use = 100;
1596
1597
1598         /* Over-exert the player */
1599         if(over_exerted)
1600         {
1601                 int oops = need_mana;
1602
1603                 /* No mana left */
1604                 p_ptr->csp = 0;
1605                 p_ptr->csp_frac = 0;
1606
1607                 /* Message */
1608 #ifdef JP
1609 msg_print("精神を集中しすぎて気を失ってしまった！");
1610 #else
1611                 msg_print("You faint from the effort!");
1612 #endif
1613
1614
1615                 /* Hack -- Bypass free action */
1616                 (void)set_paralyzed(p_ptr->paralyzed + randint1(5 * oops + 1));
1617
1618                 switch (realm)
1619                 {
1620                 case REALM_LIFE:
1621                         chg_virtue(V_VITALITY, -10);
1622                         break;
1623                 case REALM_DEATH:
1624                         chg_virtue(V_UNLIFE, -10);
1625                         break;
1626                 case REALM_DAEMON:
1627                         chg_virtue(V_JUSTICE, 10);
1628                         break;
1629                 case REALM_NATURE:
1630                         chg_virtue(V_NATURE, -10);
1631                         break;
1632                 case REALM_CRUSADE:
1633                         chg_virtue(V_JUSTICE, -10);
1634                         break;
1635                 case REALM_HEX:
1636                         chg_virtue(V_COMPASSION, 10);
1637                         break;
1638                 default:
1639                         chg_virtue(V_KNOWLEDGE, -10);
1640                         break;
1641                 }
1642
1643                 /* Damage CON (possibly permanently) */
1644                 if (randint0(100) < 50)
1645                 {
1646                         bool perm = (randint0(100) < 25);
1647
1648                         /* Message */
1649 #ifdef JP
1650 msg_print("体を悪くしてしまった！");
1651 #else
1652                         msg_print("You have damaged your health!");
1653 #endif
1654
1655
1656                         /* Reduce constitution */
1657                         (void)dec_stat(A_CON, 15 + randint1(10), perm);
1658                 }
1659         }
1660
1661         /* Window stuff */
1662         p_ptr->window |= (PW_PLAYER);
1663         p_ptr->window |= (PW_SPELL);
1664 }
1665
1666 /*!
1667  * @brief ペットになっているモンスターをソートするための比較処理
1668  * @param u モンスターの構造体配列
1669  * @param v 未使用
1670  * @param a 比較対象のモンスターID1
1671  * @param b 比較対象のモンスターID2
1672  * @return 2番目が大ならばTRUEを返す
1673  */
1674 static bool ang_sort_comp_pet_dismiss(vptr u, vptr v, int a, int b)
1675 {
1676         u16b *who = (u16b*)(u);
1677
1678         int w1 = who[a];
1679         int w2 = who[b];
1680
1681         monster_type *m_ptr1 = &m_list[w1];
1682         monster_type *m_ptr2 = &m_list[w2];
1683         monster_race *r_ptr1 = &r_info[m_ptr1->r_idx];
1684         monster_race *r_ptr2 = &r_info[m_ptr2->r_idx];
1685
1686         /* Unused */
1687         (void)v;
1688
1689         if (w1 == p_ptr->riding) return TRUE;
1690         if (w2 == p_ptr->riding) return FALSE;
1691
1692         if (m_ptr1->nickname && !m_ptr2->nickname) return TRUE;
1693         if (m_ptr2->nickname && !m_ptr1->nickname) return FALSE;
1694
1695         if (!m_ptr1->parent_m_idx && m_ptr2->parent_m_idx) return TRUE;
1696         if (!m_ptr2->parent_m_idx && m_ptr1->parent_m_idx) return FALSE;
1697
1698         if ((r_ptr1->flags1 & RF1_UNIQUE) && !(r_ptr2->flags1 & RF1_UNIQUE)) return TRUE;
1699         if ((r_ptr2->flags1 & RF1_UNIQUE) && !(r_ptr1->flags1 & RF1_UNIQUE)) return FALSE;
1700
1701         if (r_ptr1->level > r_ptr2->level) return TRUE;
1702         if (r_ptr2->level > r_ptr1->level) return FALSE;
1703
1704         if (m_ptr1->hp > m_ptr2->hp) return TRUE;
1705         if (m_ptr2->hp > m_ptr1->hp) return FALSE;
1706
1707         return w1 <= w2;
1708 }
1709
1710 /*!
1711  * @brief ペットの善悪属性に応じた維持コストの途中計算処理
1712  * @param m_ptr 計算基準となるモンスターの構造体参照ポインタ
1713  * @param inc m_ptrで指定したモンスターを維持コスト計算に加えるならTRUE、外すならFALSEを指定
1714  * @return なし
1715  */
1716 void check_pets_num_and_align(monster_type *m_ptr, bool inc)
1717 {
1718         s32b old_friend_align = friend_align;
1719         monster_race *r_ptr = &r_info[m_ptr->r_idx];
1720
1721         if (inc)
1722         {
1723                 total_friends++;
1724                 if (r_ptr->flags3 & RF3_GOOD) friend_align += r_ptr->level;
1725                 if (r_ptr->flags3 & RF3_EVIL) friend_align -= r_ptr->level;
1726         }
1727         else
1728         {
1729                 total_friends--;
1730                 if (r_ptr->flags3 & RF3_GOOD) friend_align -= r_ptr->level;
1731                 if (r_ptr->flags3 & RF3_EVIL) friend_align += r_ptr->level;
1732         }
1733
1734         if (old_friend_align != friend_align) p_ptr->update |= (PU_BONUS);
1735 }
1736
1737 /*!
1738  * @brief ペットの維持コスト計算
1739  * @return 維持コスト(%)
1740  */
1741 int calculate_upkeep(void)
1742 {
1743         s32b old_friend_align = friend_align;
1744         int m_idx;
1745         bool have_a_unique = FALSE;
1746         s32b total_friend_levels = 0;
1747
1748         total_friends = 0;
1749         friend_align = 0;
1750
1751         for (m_idx = m_max - 1; m_idx >=1; m_idx--)
1752         {
1753                 monster_type *m_ptr;
1754                 monster_race *r_ptr;
1755
1756                 m_ptr = &m_list[m_idx];
1757                 if (!m_ptr->r_idx) continue;
1758                 r_ptr = &r_info[m_ptr->r_idx];
1759
1760                 if (is_pet(m_ptr))
1761                 {
1762                         total_friends++;
1763                         if (r_ptr->flags1 & RF1_UNIQUE)
1764                         {
1765                                 if (p_ptr->pclass == CLASS_CAVALRY)
1766                                 {
1767                                         if (p_ptr->riding == m_idx)
1768                                                 total_friend_levels += (r_ptr->level+5)*2;
1769                                         else if (!have_a_unique && (r_info[m_ptr->r_idx].flags7 & RF7_RIDING))
1770                                                 total_friend_levels += (r_ptr->level+5)*7/2;
1771                                         else
1772                                                 total_friend_levels += (r_ptr->level+5)*10;
1773                                         have_a_unique = TRUE;
1774                                 }
1775                                 else
1776                                         total_friend_levels += (r_ptr->level+5)*10;
1777                         }
1778                         else
1779                                 total_friend_levels += r_ptr->level;
1780
1781                         /* Determine pet alignment */
1782                         if (r_ptr->flags3 & RF3_GOOD) friend_align += r_ptr->level;
1783                         if (r_ptr->flags3 & RF3_EVIL) friend_align -= r_ptr->level;
1784                 }
1785         }
1786         if (old_friend_align != friend_align) p_ptr->update |= (PU_BONUS);
1787         if (total_friends)
1788         {
1789                 int upkeep_factor;
1790                 upkeep_factor = (total_friend_levels - (p_ptr->lev * 80 / (cp_ptr->pet_upkeep_div)));
1791                 if (upkeep_factor < 0) upkeep_factor = 0;
1792                 if (upkeep_factor > 1000) upkeep_factor = 1000;
1793                 return upkeep_factor;
1794         }
1795         else
1796                 return 0;
1797 }
1798
1799 /*!
1800  * @brief ペットを開放するコマンドのメインルーチン
1801  * @return なし
1802  */
1803 void do_cmd_pet_dismiss(void)
1804 {
1805         monster_type    *m_ptr;
1806         bool            all_pets = FALSE;
1807         int pet_ctr, i;
1808         int Dismissed = 0;
1809
1810         u16b *who;
1811         u16b dummy_why;
1812         int max_pet = 0;
1813         int cu, cv;
1814
1815         cu = Term->scr->cu;
1816         cv = Term->scr->cv;
1817         Term->scr->cu = 0;
1818         Term->scr->cv = 1;
1819
1820         /* Allocate the "who" array */
1821         C_MAKE(who, max_m_idx, u16b);
1822
1823         /* Process the monsters (backwards) */
1824         for (pet_ctr = m_max - 1; pet_ctr >= 1; pet_ctr--)
1825         {
1826                 if (is_pet(&m_list[pet_ctr]))
1827                         who[max_pet++] = pet_ctr;
1828         }
1829
1830         /* Select the sort method */
1831         ang_sort_comp = ang_sort_comp_pet_dismiss;
1832         ang_sort_swap = ang_sort_swap_hook;
1833
1834         ang_sort(who, &dummy_why, max_pet);
1835
1836         /* Process the monsters (backwards) */
1837         for (i = 0; i < max_pet; i++)
1838         {
1839                 bool delete_this;
1840                 char friend_name[80];
1841                 bool kakunin;
1842
1843                 /* Access the monster */
1844                 pet_ctr = who[i];
1845                 m_ptr = &m_list[pet_ctr];
1846
1847                 delete_this = FALSE;
1848                 kakunin = ((pet_ctr == p_ptr->riding) || (m_ptr->nickname));
1849                 monster_desc(friend_name, m_ptr, MD_ASSUME_VISIBLE);
1850
1851                 if (!all_pets)
1852                 {
1853                         /* Hack -- health bar for this monster */
1854                         health_track(pet_ctr);
1855
1856                         /* Hack -- handle stuff */
1857                         handle_stuff();
1858
1859                         msg_format(_("%sを放しますか？ [Yes/No/Unnamed (%d体)]","Dismiss %s? [Yes/No/Unnamed (%d remain)]"), friend_name, max_pet - i);
1860
1861                         if (m_ptr->ml)
1862                                 move_cursor_relative(m_ptr->fy, m_ptr->fx);
1863
1864                         while (TRUE)
1865                         {
1866                                 char ch = inkey();
1867
1868                                 if (ch == 'Y' || ch == 'y')
1869                                 {
1870                                         delete_this = TRUE;
1871
1872                                         if (kakunin)
1873                                         {
1874                                                 msg_format(_("本当によろしいですか？ (%s) ","Are you sure? (%s) "), friend_name);
1875                                                 ch = inkey();
1876                                                 if (ch != 'Y' && ch != 'y')
1877                                                         delete_this = FALSE;
1878                                         }
1879                                         break;
1880                                 }
1881
1882                                 if (ch == 'U' || ch == 'u')
1883                                 {
1884                                         all_pets = TRUE;
1885                                         break;
1886                                 }
1887
1888                                 if (ch == ESCAPE || ch == 'N' || ch == 'n')
1889                                         break;
1890
1891                                 bell();
1892                         }
1893                 }
1894
1895                 if ((all_pets && !kakunin) || (!all_pets && delete_this))
1896                 {
1897                         if (record_named_pet && m_ptr->nickname)
1898                         {
1899                                 char m_name[80];
1900
1901                                 monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
1902                                 do_cmd_write_nikki(NIKKI_NAMED_PET, RECORD_NAMED_PET_DISMISS, m_name);
1903                         }
1904
1905                         if (pet_ctr == p_ptr->riding)
1906                         {
1907                                 msg_format(_("%sから降りた。","You have got off %s. "), friend_name);
1908
1909                                 p_ptr->riding = 0;
1910
1911                                 /* Update the monsters */
1912                                 p_ptr->update |= (PU_BONUS | PU_MONSTERS);
1913                                 p_ptr->redraw |= (PR_EXTRA | PR_UHEALTH);
1914                         }
1915
1916                         /* HACK : Add the line to message buffer */
1917                         msg_format(_("%s を放した。","Dismissed %s."), friend_name);
1918                         p_ptr->window |= (PW_MESSAGE);
1919                         window_stuff();
1920
1921                         delete_monster_idx(pet_ctr);
1922                         Dismissed++;
1923                 }
1924         }
1925
1926         Term->scr->cu = cu;
1927         Term->scr->cv = cv;
1928         Term_fresh();
1929
1930         C_KILL(who, max_m_idx, u16b);
1931
1932 #ifdef JP
1933         msg_format("%d 体のペットを放しました。", Dismissed);
1934 #else
1935         msg_format("You have dismissed %d pet%s.", Dismissed,
1936                    (Dismissed == 1 ? "" : "s"));
1937 #endif
1938         if (Dismissed == 0 && all_pets)
1939 #ifdef JP
1940                 msg_print("'U'nnamed は、乗馬以外の名前のないペットだけを全て解放します。");
1941 #else
1942                 msg_print("'U'nnamed means all your pets except named pets and your mount.");
1943 #endif
1944 }
1945
1946 /*!
1947  * @brief プレイヤーの騎乗/下馬処理判定
1948  * @param c_ptr プレイヤーの移動先マスの構造体参照ポインタ
1949  * @param now_riding TRUEなら下馬処理、FALSEならば騎乗処理
1950  * @return 可能ならばTRUEを返す
1951  */
1952 static bool player_can_ride_aux(cave_type *c_ptr, bool now_riding)
1953 {
1954         bool p_can_enter;
1955         bool old_character_xtra = character_xtra;
1956         int  old_riding = p_ptr->riding;
1957         bool old_riding_ryoute = p_ptr->riding_ryoute;
1958         bool old_old_riding_ryoute = p_ptr->old_riding_ryoute;
1959         bool old_pf_ryoute = (p_ptr->pet_extra_flags & PF_RYOUTE) ? TRUE : FALSE;
1960
1961         /* Hack -- prevent "icky" message */
1962         character_xtra = TRUE;
1963
1964         if (now_riding) p_ptr->riding = c_ptr->m_idx;
1965         else
1966         {
1967                 p_ptr->riding = 0;
1968                 p_ptr->pet_extra_flags &= ~(PF_RYOUTE);
1969                 p_ptr->riding_ryoute = p_ptr->old_riding_ryoute = FALSE;
1970         }
1971
1972         calc_bonuses();
1973
1974         p_can_enter = player_can_enter(c_ptr->feat, CEM_P_CAN_ENTER_PATTERN);
1975
1976         p_ptr->riding = old_riding;
1977         if (old_pf_ryoute) p_ptr->pet_extra_flags |= (PF_RYOUTE);
1978         else p_ptr->pet_extra_flags &= ~(PF_RYOUTE);
1979         p_ptr->riding_ryoute = old_riding_ryoute;
1980         p_ptr->old_riding_ryoute = old_old_riding_ryoute;
1981
1982         calc_bonuses();
1983
1984         character_xtra = old_character_xtra;
1985
1986         return p_can_enter;
1987 }
1988
1989 /*!
1990  * @brief プレイヤーの落馬判定処理
1991  * @param dam 落馬判定を発した際に受けたダメージ量
1992  * @param force TRUEならば強制的に落馬する
1993  * @return 実際に落馬したらTRUEを返す
1994  */
1995 bool rakuba(int dam, bool force)
1996 {
1997         int i, y, x, oy, ox;
1998         int sn = 0, sy = 0, sx = 0;
1999         char m_name[80];
2000         monster_type *m_ptr = &m_list[p_ptr->riding];
2001         monster_race *r_ptr = &r_info[m_ptr->r_idx];
2002         bool fall_dam = FALSE;
2003
2004         if (!p_ptr->riding) return FALSE;
2005         if (p_ptr->wild_mode) return FALSE;
2006
2007         if (dam >= 0 || force)
2008         {
2009                 if (!force)
2010                 {
2011                         int cur = p_ptr->skill_exp[GINOU_RIDING];
2012                         int max = s_info[p_ptr->pclass].s_max[GINOU_RIDING];
2013                         int ridinglevel = r_ptr->level;
2014
2015                         /* 落馬のしやすさ */
2016                         int rakubalevel = r_ptr->level;
2017                         if (p_ptr->riding_ryoute) rakubalevel += 20;
2018
2019                         if ((cur < max) && (max > 1000) &&
2020                             (dam / 2 + ridinglevel) > (cur / 30 + 10))
2021                         {
2022                                 int inc = 0;
2023
2024                                 if (ridinglevel > (cur / 100 + 15))
2025                                         inc += 1 + (ridinglevel - cur / 100 - 15);
2026                                 else
2027                                         inc += 1;
2028
2029                                 p_ptr->skill_exp[GINOU_RIDING] = MIN(max, cur + inc);
2030                         }
2031
2032                         /* レベルの低い乗馬からは落馬しにくい */
2033                         if (randint0(dam / 2 + rakubalevel * 2) < cur / 30 + 10)
2034                         {
2035                                 if ((((p_ptr->pclass == CLASS_BEASTMASTER) || (p_ptr->pclass == CLASS_CAVALRY)) && !p_ptr->riding_ryoute) || !one_in_(p_ptr->lev*(p_ptr->riding_ryoute ? 2 : 3) + 30))
2036                                 {
2037                                         return FALSE;
2038                                 }
2039                         }
2040                 }
2041
2042                 /* Check around the player */
2043                 for (i = 0; i < 8; i++)
2044                 {
2045                         cave_type *c_ptr;
2046
2047                         /* Access the location */
2048                         y = py + ddy_ddd[i];
2049                         x = px + ddx_ddd[i];
2050
2051                         c_ptr = &cave[y][x];
2052
2053                         if (c_ptr->m_idx) continue;
2054
2055                         /* Skip non-empty grids */
2056                         if (!cave_have_flag_grid(c_ptr, FF_MOVE) && !cave_have_flag_grid(c_ptr, FF_CAN_FLY))
2057                         {
2058                                 if (!player_can_ride_aux(c_ptr, FALSE)) continue;
2059                         }
2060
2061                         if (cave_have_flag_grid(c_ptr, FF_PATTERN)) continue;
2062
2063                         /* Count "safe" grids */
2064                         sn++;
2065
2066                         /* Randomize choice */
2067                         if (randint0(sn) > 0) continue;
2068
2069                         /* Save the safe location */
2070                         sy = y; sx = x;
2071                 }
2072                 if (!sn)
2073                 {
2074                         monster_desc(m_name, m_ptr, 0);
2075 #ifdef JP
2076 msg_format("%sから振り落とされそうになって、壁にぶつかった。",m_name);
2077                         take_hit(DAMAGE_NOESCAPE, r_ptr->level+3, "壁への衝突", -1);
2078 #else
2079                         msg_format("You have nearly fallen from %s, but bumped into wall.",m_name);
2080                         take_hit(DAMAGE_NOESCAPE, r_ptr->level+3, "bumping into wall", -1);
2081 #endif
2082                         return FALSE;
2083                 }
2084
2085                 oy = py;
2086                 ox = px;
2087
2088                 py = sy;
2089                 px = sx;
2090
2091                 /* Redraw the old spot */
2092                 lite_spot(oy, ox);
2093
2094                 /* Redraw the new spot */
2095                 lite_spot(py, px);
2096
2097                 /* Check for new panel */
2098                 verify_panel();
2099         }
2100
2101         p_ptr->riding = 0;
2102         p_ptr->pet_extra_flags &= ~(PF_RYOUTE);
2103         p_ptr->riding_ryoute = p_ptr->old_riding_ryoute = FALSE;
2104
2105         calc_bonuses();
2106
2107         p_ptr->update |= (PU_BONUS);
2108
2109         /* Update stuff */
2110         p_ptr->update |= (PU_VIEW | PU_LITE | PU_FLOW | PU_MON_LITE | PU_MONSTERS);
2111
2112         /* Window stuff */
2113         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
2114
2115         p_ptr->redraw |= (PR_EXTRA);
2116
2117         /* Update health track of mount */
2118         p_ptr->redraw |= (PR_UHEALTH);
2119
2120         if (p_ptr->levitation && !force)
2121         {
2122                 monster_desc(m_name, m_ptr, 0);
2123 #ifdef JP
2124                 msg_format("%sから落ちたが、空中でうまく体勢を立て直して着地した。",m_name);
2125 #else
2126                 msg_format("You are thrown from %s, but make a good landing.",m_name);
2127 #endif
2128         }
2129         else
2130         {
2131 #ifdef JP
2132                 take_hit(DAMAGE_NOESCAPE, r_ptr->level+3, "落馬", -1);
2133 #else
2134                 take_hit(DAMAGE_NOESCAPE, r_ptr->level+3, "Falling from riding", -1);
2135 #endif
2136                 fall_dam = TRUE;
2137         }
2138
2139         /* Move the player */
2140         if (sy && !p_ptr->is_dead)
2141                 (void)move_player_effect(py, px, MPE_DONT_PICKUP | MPE_DONT_SWAP_MON);
2142
2143         return fall_dam;
2144 }
2145
2146 /*!
2147  * @brief ペットから騎乗/下馬するコマンドのメインルーチン /
2148  * @param force 強制的に騎乗/下馬するならばTRUE
2149  * @return 騎乗/下馬できたらTRUE
2150  */
2151 bool do_riding(bool force)
2152 {
2153         int x, y, dir = 0;
2154         cave_type *c_ptr;
2155         monster_type *m_ptr;
2156
2157         if (!get_rep_dir2(&dir)) return FALSE;
2158         y = py + ddy[dir];
2159         x = px + ddx[dir];
2160         c_ptr = &cave[y][x];
2161
2162         if (p_ptr->special_defense & KATA_MUSOU) set_action(ACTION_NONE);
2163
2164         if (p_ptr->riding)
2165         {
2166                 /* Skip non-empty grids */
2167                 if (!player_can_ride_aux(c_ptr, FALSE))
2168                 {
2169 #ifdef JP
2170                         msg_print("そちらには降りられません。");
2171 #else
2172                         msg_print("You cannot go to that direction.");
2173 #endif
2174                         return FALSE;
2175                 }
2176
2177                 if (!pattern_seq(py, px, y, x)) return FALSE;
2178
2179                 if (c_ptr->m_idx)
2180                 {
2181                         /* Take a turn */
2182                         energy_use = 100;
2183
2184                         /* Message */
2185 #ifdef JP
2186                         msg_print("モンスターが立ちふさがっている！");
2187 #else
2188                         msg_print("There is a monster in the way!");
2189 #endif
2190
2191                         py_attack(y, x, 0);
2192                         return FALSE;
2193                 }
2194
2195                 p_ptr->riding = 0;
2196                 p_ptr->pet_extra_flags &= ~(PF_RYOUTE);
2197                 p_ptr->riding_ryoute = p_ptr->old_riding_ryoute = FALSE;
2198         }
2199         else
2200         {
2201                 if (p_ptr->confused)
2202                 {
2203 #ifdef JP
2204                         msg_print("混乱していて乗れない！");
2205 #else
2206                         msg_print("You are too confused!");
2207 #endif
2208                         return FALSE;
2209                 }
2210
2211                 m_ptr = &m_list[c_ptr->m_idx];
2212
2213                 if (!c_ptr->m_idx || !m_ptr->ml)
2214                 {
2215 #ifdef JP
2216                         msg_print("その場所にはモンスターはいません。");
2217 #else
2218                         msg_print("Here is no monster.");
2219 #endif
2220
2221                         return FALSE;
2222                 }
2223                 if (!is_pet(m_ptr) && !force)
2224                 {
2225 #ifdef JP
2226                         msg_print("そのモンスターはペットではありません。");
2227 #else
2228                         msg_print("That monster is not a pet.");
2229 #endif
2230
2231                         return FALSE;
2232                 }
2233                 if (!(r_info[m_ptr->r_idx].flags7 & RF7_RIDING))
2234                 {
2235 #ifdef JP
2236                         msg_print("そのモンスターには乗れなさそうだ。");
2237 #else
2238                         msg_print("This monster doesn't seem suitable for riding.");
2239 #endif
2240
2241                         return FALSE;
2242                 }
2243
2244                 if (!pattern_seq(py, px, y, x)) return FALSE;
2245
2246                 if (!player_can_ride_aux(c_ptr, TRUE))
2247                 {
2248                         /* Feature code (applying "mimic" field) */
2249                         feature_type *f_ptr = &f_info[get_feat_mimic(c_ptr)];
2250 #ifdef JP
2251                         msg_format("そのモンスターは%sの%sにいる。", f_name + f_ptr->name,
2252                                    ((!have_flag(f_ptr->flags, FF_MOVE) && !have_flag(f_ptr->flags, FF_CAN_FLY)) ||
2253                                     (!have_flag(f_ptr->flags, FF_LOS) && !have_flag(f_ptr->flags, FF_TREE))) ?
2254                                    "中" : "上");
2255 #else
2256                         msg_format("This monster is %s the %s.",
2257                                    ((!have_flag(f_ptr->flags, FF_MOVE) && !have_flag(f_ptr->flags, FF_CAN_FLY)) ||
2258                                     (!have_flag(f_ptr->flags, FF_LOS) && !have_flag(f_ptr->flags, FF_TREE))) ?
2259                                    "in" : "on", f_name + f_ptr->name);
2260 #endif
2261
2262                         return FALSE;
2263                 }
2264                 if (r_info[m_ptr->r_idx].level > randint1((p_ptr->skill_exp[GINOU_RIDING] / 50 + p_ptr->lev / 2 + 20)))
2265                 {
2266 #ifdef JP
2267                         msg_print("うまく乗れなかった。");
2268 #else
2269                         msg_print("You failed to ride.");
2270 #endif
2271
2272                         energy_use = 100;
2273
2274                         return FALSE;
2275                 }
2276
2277                 if (MON_CSLEEP(m_ptr))
2278                 {
2279                         char m_name[80];
2280                         monster_desc(m_name, m_ptr, 0);
2281                         (void)set_monster_csleep(c_ptr->m_idx, 0);
2282 #ifdef JP
2283                         msg_format("%sを起こした。", m_name);
2284 #else
2285                         msg_format("You have waked %s up.", m_name);
2286 #endif
2287                 }
2288
2289                 if (p_ptr->action == ACTION_KAMAE) set_action(ACTION_NONE);
2290
2291                 p_ptr->riding = c_ptr->m_idx;
2292
2293                 /* Hack -- remove tracked monster */
2294                 if (p_ptr->riding == p_ptr->health_who) health_track(0);
2295         }
2296
2297         energy_use = 100;
2298
2299         /* Mega-Hack -- Forget the view and lite */
2300         p_ptr->update |= (PU_UN_VIEW | PU_UN_LITE);
2301
2302         /* Update the monsters */
2303         p_ptr->update |= (PU_BONUS);
2304
2305         /* Redraw map */
2306         p_ptr->redraw |= (PR_MAP | PR_EXTRA);
2307
2308         p_ptr->redraw |= (PR_UHEALTH);
2309
2310         /* Move the player */
2311         (void)move_player_effect(y, x, MPE_HANDLE_STUFF | MPE_ENERGY_USE | MPE_DONT_PICKUP | MPE_DONT_SWAP_MON);
2312
2313         return TRUE;
2314 }
2315
2316 /*!
2317  * @brief ペットに名前をつけるコマンドのメインルーチン
2318  * @return なし
2319  */
2320 static void do_name_pet(void)
2321 {
2322         monster_type *m_ptr;
2323         char out_val[20];
2324         char m_name[80];
2325         bool old_name = FALSE;
2326         bool old_target_pet = target_pet;
2327
2328         target_pet = TRUE;
2329         if (!target_set(TARGET_KILL))
2330         {
2331                 target_pet = old_target_pet;
2332                 return;
2333         }
2334         target_pet = old_target_pet;
2335
2336         if (cave[target_row][target_col].m_idx)
2337         {
2338                 m_ptr = &m_list[cave[target_row][target_col].m_idx];
2339
2340                 if (!is_pet(m_ptr))
2341                 {
2342                         /* Message */
2343 #ifdef JP
2344                         msg_print("そのモンスターはペットではない。");
2345 #else
2346                         msg_format("This monster is not a pet.");
2347 #endif
2348                         return;
2349                 }
2350                 if (r_info[m_ptr->r_idx].flags1 & RF1_UNIQUE)
2351                 {
2352 #ifdef JP
2353                         msg_print("そのモンスターの名前は変えられない！");
2354 #else
2355                         msg_format("You cannot change name of this monster!");
2356 #endif
2357                         return;
2358                 }
2359                 monster_desc(m_name, m_ptr, 0);
2360
2361                 /* Message */
2362 #ifdef JP
2363                 msg_format("%sに名前をつける。", m_name);
2364 #else
2365                 msg_format("Name %s.", m_name);
2366 #endif
2367
2368                 msg_print(NULL);
2369
2370                 /* Start with nothing */
2371                 strcpy(out_val, "");
2372
2373                 /* Use old inscription */
2374                 if (m_ptr->nickname)
2375                 {
2376                         /* Start with the old inscription */
2377                         strcpy(out_val, quark_str(m_ptr->nickname));
2378                         old_name = TRUE;
2379                 }
2380
2381                 /* Get a new inscription (possibly empty) */
2382 #ifdef JP
2383                 if (get_string("名前: ", out_val, 15))
2384 #else
2385                 if (get_string("Name: ", out_val, 15))
2386 #endif
2387
2388                 {
2389                         if (out_val[0])
2390                         {
2391                                 /* Save the inscription */
2392                                 m_ptr->nickname = quark_add(out_val);
2393                                 if (record_named_pet)
2394                                 {
2395                                         char m_name[80];
2396
2397                                         monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
2398                                         do_cmd_write_nikki(NIKKI_NAMED_PET, RECORD_NAMED_PET_NAME, m_name);
2399                                 }
2400                         }
2401                         else
2402                         {
2403                                 if (record_named_pet && old_name)
2404                                 {
2405                                         char m_name[80];
2406
2407                                         monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
2408                                         do_cmd_write_nikki(NIKKI_NAMED_PET, RECORD_NAMED_PET_UNNAME, m_name);
2409                                 }
2410                                 m_ptr->nickname = 0;
2411                         }
2412                 }
2413         }
2414 }
2415
2416
2417 /*!
2418  * @brief ペットに関するコマンドリストのメインルーチン /
2419  * Issue a pet command
2420  * @return なし
2421  */
2422 void do_cmd_pet(void)
2423 {
2424         int                     i = 0;
2425         int                     num;
2426         int                     powers[36];
2427         cptr                    power_desc[36];
2428         bool                    flag, redraw;
2429         char                    choice;
2430         char                    out_val[160];
2431         int                     pet_ctr;
2432         monster_type    *m_ptr;
2433
2434         int mode = 0;
2435
2436         char buf[160];
2437         char target_buf[160];
2438
2439         int menu_line = use_menu ? 1 : 0;
2440
2441         num = 0;
2442
2443 #ifdef JP
2444         power_desc[num] = "ペットを放す";
2445 #else
2446         power_desc[num] = "dismiss pets";
2447 #endif
2448
2449         powers[num++] = PET_DISMISS;
2450
2451 #ifdef JP
2452         sprintf(target_buf, "ペットのターゲットを指定 (現在：%s)",
2453                 (pet_t_m_idx ? (p_ptr->image ? "何か奇妙な物" : (r_name + r_info[m_list[pet_t_m_idx].ap_r_idx].name)) : "指定なし"));
2454 #else
2455         sprintf(target_buf, "specify a target of pet (now:%s)",
2456                 (pet_t_m_idx ? (p_ptr->image ? "something strange" : (r_name + r_info[m_list[pet_t_m_idx].ap_r_idx].name)) : "nothing"));
2457 #endif
2458         power_desc[num] = target_buf;
2459
2460         powers[num++] = PET_TARGET;
2461
2462 #ifdef JP
2463         power_desc[num] = "近くにいろ";
2464 #else
2465         power_desc[num] = "stay close";
2466 #endif
2467
2468         if (p_ptr->pet_follow_distance == PET_CLOSE_DIST) mode = num;
2469         powers[num++] = PET_STAY_CLOSE;
2470
2471 #ifdef JP
2472         power_desc[num] = "ついて来い";
2473 #else
2474         power_desc[num] = "follow me";
2475 #endif
2476
2477         if (p_ptr->pet_follow_distance == PET_FOLLOW_DIST) mode = num;
2478         powers[num++] = PET_FOLLOW_ME;
2479
2480 #ifdef JP
2481         power_desc[num] = "敵を見つけて倒せ";
2482 #else
2483         power_desc[num] = "seek and destroy";
2484 #endif
2485
2486         if (p_ptr->pet_follow_distance == PET_DESTROY_DIST) mode = num;
2487         powers[num++] = PET_SEEK_AND_DESTROY;
2488
2489 #ifdef JP
2490         power_desc[num] = "少し離れていろ";
2491 #else
2492         power_desc[num] = "give me space";
2493 #endif
2494
2495         if (p_ptr->pet_follow_distance == PET_SPACE_DIST) mode = num;
2496         powers[num++] = PET_ALLOW_SPACE;
2497
2498 #ifdef JP
2499         power_desc[num] = "離れていろ";
2500 #else
2501         power_desc[num] = "stay away";
2502 #endif
2503
2504         if (p_ptr->pet_follow_distance == PET_AWAY_DIST) mode = num;
2505         powers[num++] = PET_STAY_AWAY;
2506
2507         if (p_ptr->pet_extra_flags & PF_OPEN_DOORS)
2508         {
2509 #ifdef JP
2510                 power_desc[num] = "ドアを開ける (現在:ON)";
2511 #else
2512                 power_desc[num] = "pets open doors (now On)";
2513 #endif
2514         }
2515         else
2516         {
2517 #ifdef JP
2518                 power_desc[num] = "ドアを開ける (現在:OFF)";
2519 #else
2520                 power_desc[num] = "pets open doors (now Off)";
2521 #endif
2522         }
2523         powers[num++] = PET_OPEN_DOORS;
2524
2525         if (p_ptr->pet_extra_flags & PF_PICKUP_ITEMS)
2526         {
2527 #ifdef JP
2528                 power_desc[num] = "アイテムを拾う (現在:ON)";
2529 #else
2530                 power_desc[num] = "pets pick up items (now On)";
2531 #endif
2532         }
2533         else
2534         {
2535 #ifdef JP
2536                 power_desc[num] = "アイテムを拾う (現在:OFF)";
2537 #else
2538                 power_desc[num] = "pets pick up items (now Off)";
2539 #endif
2540         }
2541         powers[num++] = PET_TAKE_ITEMS;
2542
2543         if (p_ptr->pet_extra_flags & PF_TELEPORT)
2544         {
2545 #ifdef JP
2546                 power_desc[num] = "テレポート系魔法を使う (現在:ON)";
2547 #else
2548                 power_desc[num] = "allow teleport (now On)";
2549 #endif
2550         }
2551         else
2552         {
2553 #ifdef JP
2554                 power_desc[num] = "テレポート系魔法を使う (現在:OFF)";
2555 #else
2556                 power_desc[num] = "allow teleport (now Off)";
2557 #endif
2558         }
2559         powers[num++] = PET_TELEPORT;
2560
2561         if (p_ptr->pet_extra_flags & PF_ATTACK_SPELL)
2562         {
2563 #ifdef JP
2564                 power_desc[num] = "攻撃魔法を使う (現在:ON)";
2565 #else
2566                 power_desc[num] = "allow cast attack spell (now On)";
2567 #endif
2568         }
2569         else
2570         {
2571 #ifdef JP
2572                 power_desc[num] = "攻撃魔法を使う (現在:OFF)";
2573 #else
2574                 power_desc[num] = "allow cast attack spell (now Off)";
2575 #endif
2576         }
2577         powers[num++] = PET_ATTACK_SPELL;
2578
2579         if (p_ptr->pet_extra_flags & PF_SUMMON_SPELL)
2580         {
2581 #ifdef JP
2582                 power_desc[num] = "召喚魔法を使う (現在:ON)";
2583 #else
2584                 power_desc[num] = "allow cast summon spell (now On)";
2585 #endif
2586         }
2587         else
2588         {
2589 #ifdef JP
2590                 power_desc[num] = "召喚魔法を使う (現在:OFF)";
2591 #else
2592                 power_desc[num] = "allow cast summon spell (now Off)";
2593 #endif
2594         }
2595         powers[num++] = PET_SUMMON_SPELL;
2596
2597         if (p_ptr->pet_extra_flags & PF_BALL_SPELL)
2598         {
2599 #ifdef JP
2600                 power_desc[num] = "プレイヤーを巻き込む範囲魔法を使う (現在:ON)";
2601 #else
2602                 power_desc[num] = "allow involve player in area spell (now On)";
2603 #endif
2604         }
2605         else
2606         {
2607 #ifdef JP
2608                 power_desc[num] = "プレイヤーを巻き込む範囲魔法を使う (現在:OFF)";
2609 #else
2610                 power_desc[num] = "allow involve player in area spell (now Off)";
2611 #endif
2612         }
2613         powers[num++] = PET_BALL_SPELL;
2614
2615         if (p_ptr->riding)
2616         {
2617 #ifdef JP
2618                 power_desc[num] = "ペットから降りる";
2619 #else
2620                 power_desc[num] = "get off a pet";
2621 #endif
2622         }
2623         else
2624         {
2625 #ifdef JP
2626                 power_desc[num] = "ペットに乗る";
2627 #else
2628                 power_desc[num] = "ride a pet";
2629 #endif
2630         }
2631         powers[num++] = PET_RIDING;
2632
2633 #ifdef JP
2634         power_desc[num] = "ペットに名前をつける";
2635 #else
2636         power_desc[num] = "name pets";
2637 #endif
2638
2639         powers[num++] = PET_NAME;
2640
2641         if (p_ptr->riding)
2642         {
2643                 if ((p_ptr->migite && (empty_hands(FALSE) == EMPTY_HAND_LARM) &&
2644                      object_allow_two_hands_wielding(&inventory[INVEN_RARM])) ||
2645                     (p_ptr->hidarite && (empty_hands(FALSE) == EMPTY_HAND_RARM) &&
2646                          object_allow_two_hands_wielding(&inventory[INVEN_LARM])))
2647                 {
2648                         if (p_ptr->pet_extra_flags & PF_RYOUTE)
2649                         {
2650 #ifdef JP
2651                                 power_desc[num] = "武器を片手で持つ";
2652 #else
2653                                 power_desc[num] = "use one hand to control a riding pet";
2654 #endif
2655                         }
2656                         else
2657                         {
2658 #ifdef JP
2659                                 power_desc[num] = "武器を両手で持つ";
2660 #else
2661                                 power_desc[num] = "use both hands for a weapon";
2662 #endif
2663                         }
2664
2665                         powers[num++] = PET_RYOUTE;
2666                 }
2667                 else
2668                 {
2669                         switch (p_ptr->pclass)
2670                         {
2671                         case CLASS_MONK:
2672                         case CLASS_FORCETRAINER:
2673                         case CLASS_BERSERKER:
2674                                 if (empty_hands(FALSE) == (EMPTY_HAND_RARM | EMPTY_HAND_LARM))
2675                                 {
2676                                         if (p_ptr->pet_extra_flags & PF_RYOUTE)
2677                                         {
2678 #ifdef JP
2679                                                 power_desc[num] = "片手で格闘する";
2680 #else
2681                                                 power_desc[num] = "use one hand to control a riding pet";
2682 #endif
2683                                         }
2684                                         else
2685                                         {
2686 #ifdef JP
2687                                                 power_desc[num] = "両手で格闘する";
2688 #else
2689                                                 power_desc[num] = "use both hands for melee";
2690 #endif
2691                                         }
2692
2693                                         powers[num++] = PET_RYOUTE;
2694                                 }
2695                                 else if ((empty_hands(FALSE) != EMPTY_HAND_NONE) && !buki_motteruka(INVEN_RARM) && !buki_motteruka(INVEN_LARM))
2696                                 {
2697                                         if (p_ptr->pet_extra_flags & PF_RYOUTE)
2698                                         {
2699 #ifdef JP
2700                                                 power_desc[num] = "格闘を行わない";
2701 #else
2702                                                 power_desc[num] = "use one hand to control a riding pet";
2703 #endif
2704                                         }
2705                                         else
2706                                         {
2707 #ifdef JP
2708                                                 power_desc[num] = "格闘を行う";
2709 #else
2710                                                 power_desc[num] = "use one hand for melee";
2711 #endif
2712                                         }
2713
2714                                         powers[num++] = PET_RYOUTE;
2715                                 }
2716                                 break;
2717                         }
2718                 }
2719         }
2720
2721 #ifdef ALLOW_REPEAT
2722         if (!(repeat_pull(&i) && (i >= 0) && (i < num)))
2723         {
2724 #endif /* ALLOW_REPEAT */
2725
2726         /* Nothing chosen yet */
2727         flag = FALSE;
2728
2729         /* No redraw yet */
2730         redraw = FALSE;
2731
2732         if (use_menu)
2733         {
2734                 /* Save the screen */
2735                 screen_save();
2736
2737                 /* Build a prompt */
2738 #ifdef JP
2739                 strnfmt(out_val, 78, "(コマンド、ESC=終了) コマンドを選んでください:");
2740 #else
2741                 strnfmt(out_val, 78, "(Command, ESC=exit) Choose command from menu.");
2742 #endif
2743         }
2744         else
2745         {
2746                 /* Build a prompt */
2747                 strnfmt(out_val, 78,
2748 #ifdef JP
2749                         "(コマンド %c-%c、'*'=一覧、ESC=終了) コマンドを選んでください:",
2750 #else
2751                         "(Command %c-%c, *=List, ESC=exit) Select a command: ",
2752 #endif
2753                         I2A(0), I2A(num - 1));
2754         }
2755
2756         choice = (always_show_list || use_menu) ? ESCAPE : 1;
2757
2758         /* Get a command from the user */
2759         while (!flag)
2760         {
2761                 int ask = TRUE;
2762
2763                 if (choice == ESCAPE) choice = ' ';
2764                 else if (!get_com(out_val, &choice, TRUE)) break;
2765
2766                 if (use_menu && (choice != ' '))
2767                 {
2768                         switch (choice)
2769                         {
2770                         case '0':
2771                                 screen_load();
2772                                 return;
2773
2774                         case '8':
2775                         case 'k':
2776                         case 'K':
2777                                 menu_line += (num - 1);
2778                                 break;
2779
2780                         case '2':
2781                         case 'j':
2782                         case 'J':
2783                                 menu_line++;
2784                                 break;
2785
2786                         case '4':
2787                         case 'h':
2788                         case 'H':
2789                                 menu_line = 1;
2790                                 break;
2791
2792                         case '6':
2793                         case 'l':
2794                         case 'L':
2795                                 menu_line = num;
2796                                 break;
2797
2798                         case 'x':
2799                         case 'X':
2800                         case '\r':
2801                         case '\n':
2802                                 i = menu_line - 1;
2803                                 ask = FALSE;
2804                                 break;
2805                         }
2806                         if (menu_line > num) menu_line -= num;
2807                 }
2808
2809                 /* Request redraw */
2810                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
2811                 {
2812                         /* Show the list */
2813                         if (!redraw || use_menu)
2814                         {
2815                                 byte y = 1, x = 0;
2816                                 int ctr = 0;
2817
2818                                 /* Show list */
2819                                 redraw = TRUE;
2820
2821                                 /* Save the screen */
2822                                 if (!use_menu) screen_save();
2823
2824                                 prt("", y++, x);
2825
2826                                 /* Print list */
2827                                 for (ctr = 0; ctr < num; ctr++)
2828                                 {
2829                                         /* Letter/number for power selection */
2830 #ifdef JP
2831                                         if (use_menu) sprintf(buf, "%c%s ", (ctr == mode) ? '*' : ' ', (ctr == (menu_line - 1)) ? "》" : "  ");
2832 #else
2833                                         if (use_menu) sprintf(buf, "%c%s ", (ctr == mode) ? '*' : ' ', (ctr == (menu_line - 1)) ? "> " : "  ");
2834 #endif
2835                                         else sprintf(buf, "%c%c) ", (ctr == mode) ? '*' : ' ', I2A(ctr));
2836
2837                                         strcat(buf, power_desc[ctr]);
2838
2839                                         prt(buf, y + ctr, x);
2840                                 }
2841
2842                                 prt("", y + MIN(ctr, 17), x);
2843                         }
2844
2845                         /* Hide the list */
2846                         else
2847                         {
2848                                 /* Hide list */
2849                                 redraw = FALSE;
2850
2851                                 /* Restore the screen */
2852                                 screen_load();
2853                         }
2854
2855                         /* Redo asking */
2856                         continue;
2857                 }
2858
2859                 if (!use_menu)
2860                 {
2861                         /* Note verify */
2862                         ask = (isupper(choice));
2863
2864                         /* Lowercase */
2865                         if (ask) choice = tolower(choice);
2866
2867                         /* Extract request */
2868                         i = (islower(choice) ? A2I(choice) : -1);
2869                 }
2870
2871                 /* Totally Illegal */
2872                 if ((i < 0) || (i >= num))
2873                 {
2874                         bell();
2875                         continue;
2876                 }
2877
2878                 /* Verify it */
2879                 if (ask)
2880                 {
2881                         /* Prompt */
2882 #ifdef JP
2883                         strnfmt(buf, 78, "%sを使いますか？ ", power_desc[i]);
2884 #else
2885                         strnfmt(buf, 78, "Use %s? ", power_desc[i]);
2886 #endif
2887
2888                         /* Belay that order */
2889                         if (!get_check(buf)) continue;
2890                 }
2891
2892                 /* Stop the loop */
2893                 flag = TRUE;
2894         }
2895
2896         /* Restore the screen */
2897         if (redraw) screen_load();
2898
2899         /* Abort if needed */
2900         if (!flag)
2901         {
2902                 energy_use = 0;
2903                 return;
2904         }
2905
2906 #ifdef ALLOW_REPEAT
2907         repeat_push(i);
2908         }
2909 #endif /* ALLOW_REPEAT */
2910
2911         switch (powers[i])
2912         {
2913                 case PET_DISMISS: /* Dismiss pets */
2914                 {
2915                         /* Check pets (backwards) */
2916                         for (pet_ctr = m_max - 1; pet_ctr >= 1; pet_ctr--)
2917                         {
2918                                 /* Player has pet */
2919                                 if (is_pet(&m_list[pet_ctr])) break;
2920                         }
2921
2922                         if (!pet_ctr)
2923                         {
2924 #ifdef JP
2925                                 msg_print("ペットがいない！");
2926 #else
2927                                 msg_print("You have no pets!");
2928 #endif
2929                                 break;
2930                         }
2931                         do_cmd_pet_dismiss();
2932                         (void)calculate_upkeep();
2933                         break;
2934                 }
2935                 case PET_TARGET:
2936                 {
2937                         project_length = -1;
2938                         if (!target_set(TARGET_KILL)) pet_t_m_idx = 0;
2939                         else
2940                         {
2941                                 cave_type *c_ptr = &cave[target_row][target_col];
2942                                 if (c_ptr->m_idx && (m_list[c_ptr->m_idx].ml))
2943                                 {
2944                                         pet_t_m_idx = cave[target_row][target_col].m_idx;
2945                                         p_ptr->pet_follow_distance = PET_DESTROY_DIST;
2946                                 }
2947                                 else pet_t_m_idx = 0;
2948                         }
2949                         project_length = 0;
2950
2951                         break;
2952                 }
2953                 /* Call pets */
2954                 case PET_STAY_CLOSE:
2955                 {
2956                         p_ptr->pet_follow_distance = PET_CLOSE_DIST;
2957                         pet_t_m_idx = 0;
2958                         break;
2959                 }
2960                 /* "Follow Me" */
2961                 case PET_FOLLOW_ME:
2962                 {
2963                         p_ptr->pet_follow_distance = PET_FOLLOW_DIST;
2964                         pet_t_m_idx = 0;
2965                         break;
2966                 }
2967                 /* "Seek and destoy" */
2968                 case PET_SEEK_AND_DESTROY:
2969                 {
2970                         p_ptr->pet_follow_distance = PET_DESTROY_DIST;
2971                         break;
2972                 }
2973                 /* "Give me space" */
2974                 case PET_ALLOW_SPACE:
2975                 {
2976                         p_ptr->pet_follow_distance = PET_SPACE_DIST;
2977                         break;
2978                 }
2979                 /* "Stay away" */
2980                 case PET_STAY_AWAY:
2981                 {
2982                         p_ptr->pet_follow_distance = PET_AWAY_DIST;
2983                         break;
2984                 }
2985                 /* flag - allow pets to open doors */
2986                 case PET_OPEN_DOORS:
2987                 {
2988                         if (p_ptr->pet_extra_flags & PF_OPEN_DOORS) p_ptr->pet_extra_flags &= ~(PF_OPEN_DOORS);
2989                         else p_ptr->pet_extra_flags |= (PF_OPEN_DOORS);
2990                         break;
2991                 }
2992                 /* flag - allow pets to pickup items */
2993                 case PET_TAKE_ITEMS:
2994                 {
2995                         if (p_ptr->pet_extra_flags & PF_PICKUP_ITEMS)
2996                         {
2997                                 p_ptr->pet_extra_flags &= ~(PF_PICKUP_ITEMS);
2998                                 for (pet_ctr = m_max - 1; pet_ctr >= 1; pet_ctr--)
2999                                 {
3000                                         /* Access the monster */
3001                                         m_ptr = &m_list[pet_ctr];
3002
3003                                         if (is_pet(m_ptr))
3004                                         {
3005                                                 monster_drop_carried_objects(m_ptr);
3006                                         }
3007                                 }
3008                         }
3009                         else p_ptr->pet_extra_flags |= (PF_PICKUP_ITEMS);
3010
3011                         break;
3012                 }
3013                 /* flag - allow pets to teleport */
3014                 case PET_TELEPORT:
3015                 {
3016                         if (p_ptr->pet_extra_flags & PF_TELEPORT) p_ptr->pet_extra_flags &= ~(PF_TELEPORT);
3017                         else p_ptr->pet_extra_flags |= (PF_TELEPORT);
3018                         break;
3019                 }
3020                 /* flag - allow pets to cast attack spell */
3021                 case PET_ATTACK_SPELL:
3022                 {
3023                         if (p_ptr->pet_extra_flags & PF_ATTACK_SPELL) p_ptr->pet_extra_flags &= ~(PF_ATTACK_SPELL);
3024                         else p_ptr->pet_extra_flags |= (PF_ATTACK_SPELL);
3025                         break;
3026                 }
3027                 /* flag - allow pets to cast attack spell */
3028                 case PET_SUMMON_SPELL:
3029                 {
3030                         if (p_ptr->pet_extra_flags & PF_SUMMON_SPELL) p_ptr->pet_extra_flags &= ~(PF_SUMMON_SPELL);
3031                         else p_ptr->pet_extra_flags |= (PF_SUMMON_SPELL);
3032                         break;
3033                 }
3034                 /* flag - allow pets to cast attack spell */
3035                 case PET_BALL_SPELL:
3036                 {
3037                         if (p_ptr->pet_extra_flags & PF_BALL_SPELL) p_ptr->pet_extra_flags &= ~(PF_BALL_SPELL);
3038                         else p_ptr->pet_extra_flags |= (PF_BALL_SPELL);
3039                         break;
3040                 }
3041
3042                 case PET_RIDING:
3043                 {
3044                         (void)do_riding(FALSE);
3045                         break;
3046                 }
3047
3048                 case PET_NAME:
3049                 {
3050                         do_name_pet();
3051                         break;
3052                 }
3053
3054                 case PET_RYOUTE:
3055                 {
3056                         if (p_ptr->pet_extra_flags & PF_RYOUTE) p_ptr->pet_extra_flags &= ~(PF_RYOUTE);
3057                         else p_ptr->pet_extra_flags |= (PF_RYOUTE);
3058                         p_ptr->update |= (PU_BONUS);
3059                         handle_stuff();
3060                         break;
3061                 }
3062         }
3063 }