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