src/mspells3.c

   1 /*!
   2  * @file mspells3.c
   3  * @brief ÀÄËâË¡¤Î½èÍý¼ÂÁõ / Blue magic
   4  * @date 2014/01/15
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
   7  * This software may be copied and distributed for educational, research,\n
   8  * and not for profit purposes provided that this copyright and statement\n
   9  * are included in all such copies.  Other copyrights may also apply.\n
  10  * 2014 Deskull rearranged comment for Doxygen.\n
  11  */
  12
  13 #include "angband.h"
  14
  15 #define pseudo_plev() (((p_ptr->lev + 40) * (p_ptr->lev + 40) - 1550) / 130) /*!< ¥â¥ó¥¹¥¿¡¼ËâË¡¤ò¥×¥ì¥¤¥ä¡¼¤¬»ÈÍÑ¤¹¤ë¾ì¹ç¤Î´¹»»¥ì¥Ù¥ë */
  16
  17 /*!
  18  * @brief ¼õ¤±¼è¤Ã¤¿¥â¥ó¥¹¥¿¡¼ËâË¡¤ÎID¤Ë±þ¤¸¤ÆÀÄËâË¡¤Î¸ú²Ì¾ðÊó¤ò¤Þ¤È¤á¤¿¥Õ¥©¡¼¥Þ¥Ã¥È¤òÊÖ¤¹
  19  * @param p ¾ðÊó¤òÊÖ¤¹Ê¸»úÎó»²¾È¥Ý¥¤¥ó¥¿
  20  * @param power ¥â¥ó¥¹¥¿¡¼ËâË¡¤ÎID
  21  * @return ¤Ê¤·
  22  */
  23 static void learned_info(char *p, int power)
  24 {
  25         int plev = pseudo_plev();
  26         int hp = p_ptr->chp;
  27
  28 #ifdef JP
  29         cptr s_dam = "Â»½ý:";
  30         cptr s_dur = "´ü´Ö:";
  31         cptr s_range = "ÈÏ°Ï:";
  32         cptr s_heal = "²óÉü:";
  33 #else
  34         cptr s_dam = "dam ";
  35         cptr s_dur = "dur ";
  36         cptr s_range = "range ";
  37         cptr s_heal = "heal ";
  38 #endif
  39
  40         strcpy(p, "");
  41
  42         switch (power)
  43         {
  44                 case MS_SHRIEK:
  45                 case MS_XXX1:
  46                 case MS_XXX2:
  47                 case MS_XXX3:
  48                 case MS_XXX4:
  49                 case MS_SCARE:
  50                 case MS_BLIND:
  51                 case MS_CONF:
  52                 case MS_SLOW:
  53                 case MS_SLEEP:
  54                 case MS_HAND_DOOM:
  55                 case MS_WORLD:
  56                 case MS_SPECIAL:
  57                 case MS_TELE_TO:
  58                 case MS_TELE_AWAY:
  59                 case MS_TELE_LEVEL:
  60                 case MS_DARKNESS:
  61                 case MS_MAKE_TRAP:
  62                 case MS_FORGET:
  63                 case MS_S_KIN:
  64                 case MS_S_CYBER:
  65                 case MS_S_MONSTER:
  66                 case MS_S_MONSTERS:
  67                 case MS_S_ANT:
  68                 case MS_S_SPIDER:
  69                 case MS_S_HOUND:
  70                 case MS_S_HYDRA:
  71                 case MS_S_ANGEL:
  72                 case MS_S_DEMON:
  73                 case MS_S_UNDEAD:
  74                 case MS_S_DRAGON:
  75                 case MS_S_HI_UNDEAD:
  76                 case MS_S_HI_DRAGON:
  77                 case MS_S_AMBERITE:
  78                 case MS_S_UNIQUE:
  79                         break;
  80                 case MS_BALL_MANA:
  81                 case MS_BALL_DARK:
  82                 case MS_STARBURST:
  83                         sprintf(p, " %s%d+10d10", s_dam, plev * 8 + 50);
  84                         break;
  85                 case MS_DISPEL:
  86                         break;
  87                 case MS_ROCKET:
  88                         sprintf(p, " %s%d", s_dam, hp/4);
  89                         break;
  90                 case MS_SHOOT:
  91                 {
  92                         object_type *o_ptr = NULL;
  93                         if (buki_motteruka(INVEN_RARM)) o_ptr = &inventory[INVEN_RARM];
  94                         else if (buki_motteruka(INVEN_LARM)) o_ptr = &inventory[INVEN_LARM];
  95                         else
  96                                 sprintf(p, " %s1", s_dam);
  97                         if (o_ptr)
  98                                 sprintf(p, " %s%dd%d+%d", s_dam, o_ptr->dd, o_ptr->ds, o_ptr->to_d);
  99                         break;
 100                 }
 101                 case MS_BR_ACID:
 102                 case MS_BR_ELEC:
 103                 case MS_BR_FIRE:
 104                 case MS_BR_COLD:
 105                 case MS_BR_POIS:
 106                 case MS_BR_NUKE:
 107                         sprintf(p, " %s%d", s_dam, hp/3);
 108                         break;
 109                 case MS_BR_NEXUS:
 110                         sprintf(p, " %s%d", s_dam, MIN(hp/3, 250));
 111                         break;
 112                 case MS_BR_TIME:
 113                         sprintf(p, " %s%d", s_dam, MIN(hp/3, 150));
 114                         break;
 115                 case MS_BR_GRAVITY:
 116                         sprintf(p, " %s%d", s_dam, MIN(hp/3, 200));
 117                         break;
 118                 case MS_BR_MANA:
 119                         sprintf(p, " %s%d", s_dam, MIN(hp/3, 250));
 120                         break;
 121                 case MS_BR_NETHER:
 122                 case MS_BR_LITE:
 123                 case MS_BR_DARK:
 124                 case MS_BR_CONF:
 125                 case MS_BR_SOUND:
 126                 case MS_BR_CHAOS:
 127                 case MS_BR_DISEN:
 128                 case MS_BR_SHARDS:
 129                 case MS_BR_PLASMA:
 130                         sprintf(p, " %s%d", s_dam, hp/6);
 131                         break;
 132                 case MS_BR_INERTIA:
 133                 case MS_BR_FORCE:
 134                         sprintf(p, " %s%d", s_dam, MIN(hp/6, 200));
 135                         break;
 136                 case MS_BR_DISI:
 137                         sprintf(p, " %s%d", s_dam, MIN(hp/6, 150));
 138                         break;
 139                 case MS_BALL_NUKE:
 140                         sprintf(p, " %s%d+10d6", s_dam, plev * 2);
 141                         break;
 142                 case MS_BALL_CHAOS:
 143                         sprintf(p, " %s%d+10d10", s_dam, plev * 4);
 144                         break;
 145                 case MS_BALL_ACID:
 146                         sprintf(p, " %s15+d%d", s_dam, plev * 6);
 147                         break;
 148                 case MS_BALL_ELEC:
 149                         sprintf(p, " %s8+d%d", s_dam, plev * 3);
 150                         break;
 151                 case MS_BALL_FIRE:
 152                         sprintf(p, " %s10+d%d", s_dam, plev * 7);
 153                         break;
 154                 case MS_BALL_COLD:
 155                         sprintf(p, " %s10+d%d", s_dam, plev * 3);
 156                         break;
 157                 case MS_BALL_POIS:
 158                         sprintf(p, " %s12d2", s_dam);
 159                         break;
 160                 case MS_BALL_NETHER:
 161                         sprintf(p, " %s%d+10d10", s_dam, plev * 2 + 50);
 162                         break;
 163                 case MS_BALL_WATER:
 164                         sprintf(p, " %s50+d%d", s_dam, plev * 4);
 165                         break;
 166                 case MS_DRAIN_MANA:
 167                         sprintf(p, " %sd%d+%d", s_heal, plev, plev);
 168                         break;
 169                 case MS_MIND_BLAST:
 170                         sprintf(p, " %s8d8", s_dam);
 171                         break;
 172                 case MS_BRAIN_SMASH:
 173                         sprintf(p, " %s12d15", s_dam);
 174                         break;
 175                 case MS_CAUSE_1:
 176                         sprintf(p, " %s3d8", s_dam);
 177                         break;
 178                 case MS_CAUSE_2:
 179                         sprintf(p, " %s8d8", s_dam);
 180                         break;
 181                 case MS_CAUSE_3:
 182                         sprintf(p, " %s10d15", s_dam);
 183                         break;
 184                 case MS_CAUSE_4:
 185                         sprintf(p, " %s15d15", s_dam);
 186                         break;
 187                 case MS_BOLT_ACID:
 188                         sprintf(p, " %s%d+7d8", s_dam, plev * 2 / 3);
 189                         break;
 190                 case MS_BOLT_ELEC:
 191                         sprintf(p, " %s%d+4d8", s_dam, plev * 2 / 3);
 192                         break;
 193                 case MS_BOLT_FIRE:
 194                         sprintf(p, " %s%d+9d8", s_dam, plev * 2 / 3);
 195                         break;
 196                 case MS_BOLT_COLD:
 197                         sprintf(p, " %s%d+6d8", s_dam, plev * 2 / 3);
 198                         break;
 199                 case MS_BOLT_NETHER:
 200                         sprintf(p, " %s%d+5d5", s_dam, 30 + plev * 8 / 3);
 201                         break;
 202                 case MS_BOLT_WATER:
 203                         sprintf(p, " %s%d+10d10", s_dam, plev * 2);
 204                         break;
 205                 case MS_BOLT_MANA:
 206                         sprintf(p, " %s50+d%d", s_dam, plev * 7);
 207                         break;
 208                 case MS_BOLT_PLASMA:
 209                         sprintf(p, " %s%d+8d7", s_dam, plev * 2 + 10);
 210                         break;
 211                 case MS_BOLT_ICE:
 212                         sprintf(p, " %s%d+6d6", s_dam, plev * 2);
 213                         break;
 214                 case MS_MAGIC_MISSILE:
 215                         sprintf(p, " %s%d+2d6", s_dam, plev * 2 / 3);
 216                         break;
 217                 case MS_SPEED:
 218                         sprintf(p, " %sd%d+%d", s_dur, 20+plev, plev);
 219                         break;
 220                 case MS_HEAL:
 221                         sprintf(p, " %s%d", s_heal, plev*4);
 222                         break;
 223                 case MS_INVULNER:
 224                         sprintf(p, " %sd7+7", s_dur);
 225                         break;
 226                 case MS_BLINK:
 227                         sprintf(p, " %s10", s_range);
 228                         break;
 229                 case MS_TELEPORT:
 230                         sprintf(p, " %s%d", s_range, plev * 5);
 231                         break;
 232                 case MS_PSY_SPEAR:
 233                         sprintf(p, " %s100+d%d", s_dam, plev * 3);
 234                         break;
 235                 case MS_RAISE_DEAD:
 236                         sprintf(p, " %s5", s_range);
 237                         break;
 238                 default:
 239                         break;
 240         }
 241 }
 242
 243
 244 /*!
 245  * @brief »ÈÍÑ²ÄÇ½¤ÊÀÄËâË¡¤òÁªÂò¤¹¤ë /
 246  * Allow user to choose a imitation.
 247  * @param sn ÁªÂò¤·¤¿¥â¥ó¥¹¥¿¡¼¹¶·âID¡¢¥¥ã¥ó¥»¥ë¤Î¾ì¹ç-1¡¢ÉÔÀµ¤ÊÁªÂò¤Î¾ì¹ç-2¤òÊÖ¤¹
 248  * @return È¯Æ°²ÄÇ½¤ÊËâË¡¤òÁªÂò¤·¤¿¾ì¹çTRUE¡¢¥¥ã¥ó¥»¥ë½èÍý¤«ÉÔÀµ¤ÊÁªÂò¤¬¹Ô¤ï¤ì¤¿¾ì¹çFALSE¤òÊÖ¤¹¡£
 249  * @details
 250  * If a valid spell is chosen, saves it in '*sn' and returns TRUE\n
 251  * If the user hits escape, returns FALSE, and set '*sn' to -1\n
 252  * If there are no legal choices, returns FALSE, and sets '*sn' to -2\n
 253  *\n
 254  * The "prompt" should be "cast", "recite", or "study"\n
 255  * The "known" should be TRUE for cast/pray, FALSE for study\n
 256  *\n
 257  * nb: This function has a (trivial) display bug which will be obvious\n
 258  * when you run it. It's probably easy to fix but I haven't tried,\n
 259  * sorry.\n
 260  */
 261 static int get_learned_power(int *sn)
 262 {
 263         int             i = 0;
 264         int             num = 0;
 265         int             y = 1;
 266         int             x = 18;
 267         int             minfail = 0;
 268         int             plev = p_ptr->lev;
 269         int             chance = 0;
 270         int             ask = TRUE, mode = 0;
 271         int             spellnum[MAX_MONSPELLS];
 272         char            ch;
 273         char            choice;
 274         char            out_val[160];
 275         char            comment[80];
 276         s32b            f4 = 0, f5 = 0, f6 = 0;
 277 #ifdef JP
 278 cptr            p = "ËâË¡";
 279 #else
 280         cptr            p = "magic";
 281 #endif
 282
 283         monster_power   spell;
 284         bool            flag, redraw;
 285         int menu_line = (use_menu ? 1 : 0);
 286
 287         /* Assume cancelled */
 288         *sn = (-1);
 289
 290         /* Nothing chosen yet */
 291         flag = FALSE;
 292
 293         /* No redraw yet */
 294         redraw = FALSE;
 295
 296 #ifdef ALLOW_REPEAT /* TNB */
 297
 298         /* Get the spell, if available */
 299         if (repeat_pull(sn))
 300         {
 301                 /* Success */
 302                 return (TRUE);
 303         }
 304
 305 #endif /* ALLOW_REPEAT -- TNB */
 306
 307         if (use_menu)
 308         {
 309                 screen_save();
 310
 311                 while(!mode)
 312                 {
 313 #ifdef JP
 314                         prt(format(" %s ¥Ü¥ë¥È", (menu_line == 1) ? "¡Õ" : "  "), 2, 14);
 315                         prt(format(" %s ¥Ü¡¼¥ë", (menu_line == 2) ? "¡Õ" : "  "), 3, 14);
 316                         prt(format(" %s ¥Ö¥ì¥¹", (menu_line == 3) ? "¡Õ" : "  "), 4, 14);
 317                         prt(format(" %s ¾¤´", (menu_line == 4) ? "¡Õ" : "  "), 5, 14);
 318                         prt(format(" %s ¤½¤ÎÂ¾", (menu_line == 5) ? "¡Õ" : "  "), 6, 14);
 319                         prt("¤É¤Î¼ïÎà¤ÎËâË¡¤ò»È¤¤¤Þ¤¹¤«¡©", 0, 0);
 320 #else
 321                         prt(format(" %s bolt", (menu_line == 1) ? "> " : "  "), 2, 14);
 322                         prt(format(" %s ball", (menu_line == 2) ? "> " : "  "), 3, 14);
 323                         prt(format(" %s breath", (menu_line == 3) ? "> " : "  "), 4, 14);
 324                         prt(format(" %s sommoning", (menu_line == 4) ? "> " : "  "), 5, 14);
 325                         prt(format(" %s others", (menu_line == 5) ? "> " : "  "), 6, 14);
 326                         prt("use which type of magic? ", 0, 0);
 327 #endif
 328                         choice = inkey();
 329                         switch(choice)
 330                         {
 331                         case ESCAPE:
 332                         case 'z':
 333                         case 'Z':
 334                                 screen_load();
 335                                 return FALSE;
 336                         case '2':
 337                         case 'j':
 338                         case 'J':
 339                                 menu_line++;
 340                                 break;
 341                         case '8':
 342                         case 'k':
 343                         case 'K':
 344                                 menu_line+= 4;
 345                                 break;
 346                         case '\r':
 347                         case 'x':
 348                         case 'X':
 349                                 mode = menu_line;
 350                                 break;
 351                         }
 352                         if (menu_line > 5) menu_line -= 5;
 353                 }
 354                 screen_load();
 355         }
 356         else
 357         {
 358 #ifdef JP
 359         sprintf(comment, "[A]¥Ü¥ë¥È, [B]¥Ü¡¼¥ë, [C]¥Ö¥ì¥¹, [D]¾¤´, [E]¤½¤ÎÂ¾:");
 360 #else
 361         sprintf(comment, "[A] bolt, [B] ball, [C] breath, [D] summoning, [E] others:");
 362 #endif
 363         while (TRUE)
 364         {
 365                 if (!get_com(comment, &ch, TRUE))
 366                 {
 367                         return FALSE;
 368                 }
 369                 if (ch == 'A' || ch == 'a')
 370                 {
 371                         mode = 1;
 372                         break;
 373                 }
 374                 if (ch == 'B' || ch == 'b')
 375                 {
 376                         mode = 2;
 377                         break;
 378                 }
 379                 if (ch == 'C' || ch == 'c')
 380                 {
 381                         mode = 3;
 382                         break;
 383                 }
 384                 if (ch == 'D' || ch == 'd')
 385                 {
 386                         mode = 4;
 387                         break;
 388                 }
 389                 if (ch == 'E' || ch == 'e')
 390                 {
 391                         mode = 5;
 392                         break;
 393                 }
 394         }
 395         }
 396
 397         set_rf_masks(&f4, &f5, &f6, mode);
 398
 399         for (i = 0, num = 0; i < 32; i++)
 400         {
 401                 if ((0x00000001 << i) & f4) spellnum[num++] = i;
 402         }
 403         for (; i < 64; i++)
 404         {
 405                 if ((0x00000001 << (i - 32)) & f5) spellnum[num++] = i;
 406         }
 407         for (; i < 96; i++)
 408         {
 409                 if ((0x00000001 << (i - 64)) & f6) spellnum[num++] = i;
 410         }
 411         for (i = 0; i < num; i++)
 412         {
 413                 if (p_ptr->magic_num2[spellnum[i]])
 414                 {
 415                         if (use_menu) menu_line = i+1;
 416                         break;
 417                 }
 418         }
 419         if (i == num)
 420         {
 421 #ifdef JP
 422                 msg_print("¤½¤Î¼ïÎà¤ÎËâË¡¤Ï³Ð¤¨¤Æ¤¤¤Ê¤¤¡ª");
 423 #else
 424                 msg_print("You don't know any spell of this type.");
 425 #endif
 426                 return (FALSE);
 427         }
 428
 429         /* Build a prompt (accept all spells) */
 430         (void)strnfmt(out_val, 78,
 431 #ifdef JP
 432                       "(%c-%c, '*'¤Ç°ìÍ÷, ESC) ¤É¤Î%s¤ò¾§¤¨¤Þ¤¹¤«¡©",
 433 #else
 434                       "(%c-%c, *=List, ESC=exit) Use which %s? ",
 435 #endif
 436                       I2A(0), I2A(num - 1), p);
 437
 438         if (use_menu) screen_save();
 439
 440         /* Get a spell from the user */
 441
 442         choice= (always_show_list || use_menu) ? ESCAPE:1 ;
 443         while (!flag)
 444         {
 445                 if(choice==ESCAPE) choice = ' ';
 446                 else if( !get_com(out_val, &choice, TRUE) )break;
 447
 448                 if (use_menu && choice != ' ')
 449                 {
 450                         switch(choice)
 451                         {
 452                                 case '0':
 453                                 {
 454                                         screen_load();
 455                                         return (FALSE);
 456                                 }
 457
 458                                 case '8':
 459                                 case 'k':
 460                                 case 'K':
 461                                 {
 462                                         do
 463                                         {
 464                                                 menu_line += (num-1);
 465                                                 if (menu_line > num) menu_line -= num;
 466                                         } while(!p_ptr->magic_num2[spellnum[menu_line-1]]);
 467                                         break;
 468                                 }
 469
 470                                 case '2':
 471                                 case 'j':
 472                                 case 'J':
 473                                 {
 474                                         do
 475                                         {
 476                                                 menu_line++;
 477                                                 if (menu_line > num) menu_line -= num;
 478                                         } while(!p_ptr->magic_num2[spellnum[menu_line-1]]);
 479                                         break;
 480                                 }
 481
 482                                 case '6':
 483                                 case 'l':
 484                                 case 'L':
 485                                 {
 486                                         menu_line=num;
 487                                         while(!p_ptr->magic_num2[spellnum[menu_line-1]]) menu_line--;
 488                                         break;
 489                                 }
 490
 491                                 case '4':
 492                                 case 'h':
 493                                 case 'H':
 494                                 {
 495                                         menu_line=1;
 496                                         while(!p_ptr->magic_num2[spellnum[menu_line-1]]) menu_line++;
 497                                         break;
 498                                 }
 499
 500                                 case 'x':
 501                                 case 'X':
 502                                 case '\r':
 503                                 {
 504                                         i = menu_line - 1;
 505                                         ask = FALSE;
 506                                         break;
 507                                 }
 508                         }
 509                 }
 510                 /* Request redraw */
 511                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
 512                 {
 513                         /* Show the list */
 514                         if (!redraw || use_menu)
 515                         {
 516                                 char psi_desc[80];
 517
 518                                 /* Show list */
 519                                 redraw = TRUE;
 520
 521                                 /* Save the screen */
 522                                 if (!use_menu) screen_save();
 523
 524                                 /* Display a list of spells */
 525                                 prt("", y, x);
 526 #ifdef JP
 527 put_str("Ì¾Á°", y, x + 5);
 528 #else
 529                                 put_str("Name", y, x + 5);
 530 #endif
 531
 532 #ifdef JP
 533 put_str("MP ¼ºÎ¨ ¸ú²Ì", y, x + 33);
 534 #else
 535                                 put_str("SP Fail Info", y, x + 32);
 536 #endif
 537
 538
 539                                 /* Dump the spells */
 540                                 for (i = 0; i < num; i++)
 541                                 {
 542                                         int need_mana;
 543
 544                                         prt("", y + i + 1, x);
 545                                         if (!p_ptr->magic_num2[spellnum[i]]) continue;
 546
 547                                         /* Access the spell */
 548                                         spell = monster_powers[spellnum[i]];
 549
 550                                         chance = spell.fail;
 551
 552                                         /* Reduce failure rate by "effective" level adjustment */
 553                                         if (plev > spell.level) chance -= 3 * (plev - spell.level);
 554                                         else chance += (spell.level - plev);
 555
 556                                         /* Reduce failure rate by INT/WIS adjustment */
 557                                         chance -= 3 * (adj_mag_stat[p_ptr->stat_ind[A_INT]] - 1);
 558
 559                                         chance = mod_spell_chance_1(chance);
 560
 561                                         need_mana = mod_need_mana(monster_powers[spellnum[i]].smana, 0, REALM_NONE);
 562
 563                                         /* Not enough mana to cast */
 564                                         if (need_mana > p_ptr->csp)
 565                                         {
 566                                                 chance += 5 * (need_mana - p_ptr->csp);
 567                                         }
 568
 569                                         /* Extract the minimum failure rate */
 570                                         minfail = adj_mag_fail[p_ptr->stat_ind[A_INT]];
 571
 572                                         /* Minimum failure rate */
 573                                         if (chance < minfail) chance = minfail;
 574
 575                                         /* Stunning makes spells harder */
 576                                         if (p_ptr->stun > 50) chance += 25;
 577                                         else if (p_ptr->stun) chance += 15;
 578
 579                                         /* Always a 5 percent chance of working */
 580                                         if (chance > 95) chance = 95;
 581
 582                                         chance = mod_spell_chance_2(chance);
 583
 584                                         /* Get info */
 585                                         learned_info(comment, spellnum[i]);
 586
 587                                         if (use_menu)
 588                                         {
 589 #ifdef JP
 590                                                 if (i == (menu_line-1)) strcpy(psi_desc, "  ¡Õ");
 591 #else
 592                                                 if (i == (menu_line-1)) strcpy(psi_desc, "  > ");
 593 #endif
 594                                                 else strcpy(psi_desc, "    ");
 595                                         }
 596                                         else sprintf(psi_desc, "  %c)", I2A(i));
 597
 598                                         /* Dump the spell --(-- */
 599                                         strcat(psi_desc, format(" %-26s %3d %3d%%%s",
 600                                                 spell.name, need_mana,
 601                                                 chance, comment));
 602                                         prt(psi_desc, y + i + 1, x);
 603                                 }
 604
 605                                 /* Clear the bottom line */
 606                                 if (y < 22) prt("", y + i + 1, x);
 607                         }
 608
 609                         /* Hide the list */
 610                         else
 611                         {
 612                                 /* Hide list */
 613                                 redraw = FALSE;
 614
 615                                 /* Restore the screen */
 616                                 screen_load();
 617                         }
 618
 619                         /* Redo asking */
 620                         continue;
 621                 }
 622
 623                 if (!use_menu)
 624                 {
 625                         /* Note verify */
 626                         ask = isupper(choice);
 627
 628                         /* Lowercase */
 629                         if (ask) choice = tolower(choice);
 630
 631                         /* Extract request */
 632                         i = (islower(choice) ? A2I(choice) : -1);
 633                 }
 634
 635                 /* Totally Illegal */
 636                 if ((i < 0) || (i >= num) || !p_ptr->magic_num2[spellnum[i]])
 637                 {
 638                         bell();
 639                         continue;
 640                 }
 641
 642                 /* Save the spell index */
 643                 spell = monster_powers[spellnum[i]];
 644
 645                 /* Verify it */
 646                 if (ask)
 647                 {
 648                         char tmp_val[160];
 649
 650                         /* Prompt */
 651 #ifdef JP
 652                         (void) strnfmt(tmp_val, 78, "%s¤ÎËâË¡¤ò¾§¤¨¤Þ¤¹¤«¡©", monster_powers[spellnum[i]].name);
 653 #else
 654                         (void)strnfmt(tmp_val, 78, "Use %s? ", monster_powers[spellnum[i]].name);
 655 #endif
 656
 657
 658                         /* Belay that order */
 659                         if (!get_check(tmp_val)) continue;
 660                 }
 661
 662                 /* Stop the loop */
 663                 flag = TRUE;
 664         }
 665
 666         /* Restore the screen */
 667         if (redraw) screen_load();
 668
 669         /* Show choices */
 670         p_ptr->window |= (PW_SPELL);
 671
 672         /* Window stuff */
 673         window_stuff();
 674
 675         /* Abort if needed */
 676         if (!flag) return (FALSE);
 677
 678         /* Save the choice */
 679         (*sn) = spellnum[i];
 680
 681 #ifdef ALLOW_REPEAT /* TNB */
 682
 683         repeat_push(*sn);
 684
 685 #endif /* ALLOW_REPEAT -- TNB */
 686
 687         /* Success */
 688         return (TRUE);
 689 }
 690
 691
 692 /*!
 693  * @brief ÀÄËâË¡¤ÎÈ¯Æ° /
 694  * do_cmd_cast calls this function if the player's class is 'blue-mage'.
 695  * @param spell È¯Æ°¤¹¤ë¥â¥ó¥¹¥¿¡¼¹¶·â¤ÎID
 696  * @param success TRUE¤ÏÀ®¸ù»þ¡¢FALSE¤Ï¼ºÇÔ»þ¤Î½èÍý¤ò¹Ô¤¦
 697  * @return ½èÍý¤ò¼Â¹Ô¤·¤¿¤éTRUE¡¢¥¥ã¥ó¥»¥ë¤·¤¿¾ì¹çFALSE¤òÊÖ¤¹¡£
 698  */
 699 static bool cast_learned_spell(int spell, bool success)
 700 {
 701         int             dir;
 702         int             plev = pseudo_plev();
 703         int     summon_lev = p_ptr->lev * 2 / 3 + randint1(p_ptr->lev/2);
 704         int             hp = p_ptr->chp;
 705         int             damage = 0;
 706         bool   pet = success;
 707         bool   no_trump = FALSE;
 708         u32b p_mode, u_mode = 0L, g_mode;
 709
 710         if (pet)
 711         {
 712                 p_mode = PM_FORCE_PET;
 713                 g_mode = 0;
 714         }
 715         else
 716         {
 717                 p_mode = PM_NO_PET;
 718                 g_mode = PM_ALLOW_GROUP;
 719         }
 720
 721         if (!success || (randint1(50+plev) < plev/10)) u_mode = PM_ALLOW_UNIQUE;
 722
 723         /* spell code */
 724         switch (spell)
 725         {
 726         case MS_SHRIEK:
 727         msg_print(_("¤«¤ó¹â¤¤¶âÀÚ¤êÀ¼¤ò¤¢¤²¤¿¡£", "You make a high pitched shriek."));
 728                 aggravate_monsters(0);
 729                 break;
 730         case MS_XXX1:
 731                 break;
 732         case MS_DISPEL:
 733         {
 734                 int m_idx;
 735
 736                 if (!target_set(TARGET_KILL)) return FALSE;
 737                 m_idx = cave[target_row][target_col].m_idx;
 738                 if (!m_idx) break;
 739                 if (!player_has_los_bold(target_row, target_col)) break;
 740                 if (!projectable(py, px, target_row, target_col)) break;
 741                 dispel_monster_status(m_idx);
 742                 break;
 743         }
 744         case MS_ROCKET:
 745                 if (!get_aim_dir(&dir)) return FALSE;
 746
 747         msg_print(_("¥í¥±¥Ã¥È¤òÈ¯¼Í¤·¤¿¡£", "You fire a rocket."));
 748         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_ROCKET), plev, DAM_ROLL);
 749                 fire_rocket(GF_ROCKET, dir, damage, 2);
 750                 break;
 751         case MS_SHOOT:
 752         {
 753                 object_type *o_ptr = NULL;
 754
 755                 if (!get_aim_dir(&dir)) return FALSE;
 756
 757         msg_print(_("Ìð¤òÊü¤Ã¤¿¡£", "You fire an arrow."));
 758         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_SHOOT), plev, DAM_ROLL);
 759                 fire_bolt(GF_ARROW, dir, damage);
 760                 break;
 761         }
 762         case MS_XXX2:
 763                 break;
 764         case MS_XXX3:
 765                 break;
 766         case MS_XXX4:
 767                 break;
 768         case MS_BR_ACID:
 769                 if (!get_aim_dir(&dir)) return FALSE;
 770
 771         msg_print(_("»À¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe acid."));
 772         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_ACID), plev, DAM_ROLL);
 773                 fire_ball(GF_ACID, dir, damage, (plev > 40 ? -3 : -2));
 774                 break;
 775         case MS_BR_ELEC:
 776                 if (!get_aim_dir(&dir)) return FALSE;
 777
 778         msg_print(_("°ðºÊ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe lightning."));
 779         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_ELEC), plev, DAM_ROLL);
 780                 fire_ball(GF_ELEC, dir, damage, (plev > 40 ? -3 : -2));
 781                 break;
 782         case MS_BR_FIRE:
 783                 if (!get_aim_dir(&dir)) return FALSE;
 784
 785         msg_print(_("²Ð±ê¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe fire."));
 786         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_FIRE), plev, DAM_ROLL);
 787                 fire_ball(GF_FIRE, dir, damage, (plev > 40 ? -3 : -2));
 788                 break;
 789         case MS_BR_COLD:
 790         if (!get_aim_dir(&dir)) return FALSE;
 791
 792         msg_print(_("Îäµ¤¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe frost."));
 793         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_COLD), plev, DAM_ROLL);
 794                 fire_ball(GF_COLD, dir, damage, (plev > 40 ? -3 : -2));
 795                 break;
 796         case MS_BR_POIS:
 797         if (!get_aim_dir(&dir)) return FALSE;
 798
 799         msg_print(_("¥¬¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe gas."));
 800         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_POIS), plev, DAM_ROLL);
 801                 fire_ball(GF_POIS, dir, damage, (plev > 40 ? -3 : -2));
 802                 break;
 803         case MS_BR_NETHER:
 804         if (!get_aim_dir(&dir)) return FALSE;
 805
 806         msg_print(_("ÃÏ¹ö¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe nether."));
 807         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_NETH), plev, DAM_ROLL);
 808                 fire_ball(GF_NETHER, dir, damage, (plev > 40 ? -3 : -2));
 809                 break;
 810         case MS_BR_LITE:
 811                 if (!get_aim_dir(&dir)) return FALSE;
 812
 813         msg_print(_("Á®¸÷¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe light."));
 814         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_LITE), plev, DAM_ROLL);
 815                 fire_ball(GF_LITE, dir, damage, (plev > 40 ? -3 : -2));
 816                 break;
 817         case MS_BR_DARK:
 818                 if (!get_aim_dir(&dir)) return FALSE;
 819
 820         msg_print(_("°Å¹õ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe darkness."));
 821         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_DARK), plev, DAM_ROLL);
 822                 fire_ball(GF_DARK, dir, damage, (plev > 40 ? -3 : -2));
 823                 break;
 824         case MS_BR_CONF:
 825                 if (!get_aim_dir(&dir)) return FALSE;
 826
 827         msg_print(_("º®Íð¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe confusion."));
 828         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_CONF), plev, DAM_ROLL);
 829                 fire_ball(GF_CONFUSION, dir, damage, (plev > 40 ? -3 : -2));
 830                 break;
 831         case MS_BR_SOUND:
 832                 if (!get_aim_dir(&dir)) return FALSE;
 833
 834         msg_print(_("¹ì²»¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe sound."));
 835         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_SOUN), plev, DAM_ROLL);
 836                 fire_ball(GF_SOUND, dir, damage, (plev > 40 ? -3 : -2));
 837                 break;
 838         case MS_BR_CHAOS:
 839                 if (!get_aim_dir(&dir)) return FALSE;
 840
 841         msg_print(_("¥«¥ª¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe chaos."));
 842         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_CHAO), plev, DAM_ROLL);
 843                 fire_ball(GF_CHAOS, dir, damage, (plev > 40 ? -3 : -2));
 844                 break;
 845         case MS_BR_DISEN:
 846                 if (!get_aim_dir(&dir)) return FALSE;
 847
 848         msg_print(_("Îô²½¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe disenchantment."));
 849         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_DISE), plev, DAM_ROLL);
 850                 fire_ball(GF_DISENCHANT, dir, damage, (plev > 40 ? -3 : -2));
 851                 break;
 852         case MS_BR_NEXUS:
 853                 if (!get_aim_dir(&dir)) return FALSE;
 854
 855         msg_print(_("°ø²Ìº®Íð¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe nexus."));
 856         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_NEXU), plev, DAM_ROLL);
 857                 fire_ball(GF_NEXUS, dir, damage, (plev > 40 ? -3 : -2));
 858                 break;
 859         case MS_BR_TIME:
 860                 if (!get_aim_dir(&dir)) return FALSE;
 861
 862         msg_print(_("»þ´ÖµÕÅ¾¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe time."));
 863         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_TIME), plev, DAM_ROLL);
 864                 fire_ball(GF_TIME, dir, damage, (plev > 40 ? -3 : -2));
 865                 break;
 866         case MS_BR_INERTIA:
 867                 if (!get_aim_dir(&dir)) return FALSE;
 868
 869         msg_print(_("ÃÙÆß¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe inertia."));
 870         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_INER), plev, DAM_ROLL);
 871                 fire_ball(GF_INERTIA, dir, damage, (plev > 40 ? -3 : -2));
 872                 break;
 873         case MS_BR_GRAVITY:
 874                 if (!get_aim_dir(&dir)) return FALSE;
 875
 876         msg_print(_("½ÅÎÏ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe gravity."));
 877         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_GRAV), plev, DAM_ROLL);
 878                 fire_ball(GF_GRAVITY, dir, damage, (plev > 40 ? -3 : -2));
 879                 break;
 880         case MS_BR_SHARDS:
 881         if (!get_aim_dir(&dir)) return FALSE;
 882
 883         msg_print(_("ÇËÊÒ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe shards."));
 884         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_SHAR), plev, DAM_ROLL);
 885                 fire_ball(GF_SHARDS, dir, damage, (plev > 40 ? -3 : -2));
 886                 break;
 887         case MS_BR_PLASMA:
 888         if (!get_aim_dir(&dir)) return FALSE;
 889
 890         msg_print(_("¥×¥é¥º¥Þ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe plasma."));
 891         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_PLAS), plev, DAM_ROLL);
 892                 fire_ball(GF_PLASMA, dir, damage, (plev > 40 ? -3 : -2));
 893                 break;
 894         case MS_BR_FORCE:
 895         if (!get_aim_dir(&dir)) return FALSE;
 896
 897         msg_print(_("¥Õ¥©¡¼¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe force."));
 898         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_WALL), plev, DAM_ROLL);
 899                 fire_ball(GF_FORCE, dir, damage, (plev > 40 ? -3 : -2));
 900                 break;
 901         case MS_BR_MANA:
 902                 if (!get_aim_dir(&dir)) return FALSE;
 903
 904         msg_print(_("ËâÎÏ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe mana."));
 905         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_MANA), plev, DAM_ROLL);
 906                 fire_ball(GF_MANA, dir, damage, (plev > 40 ? -3 : -2));
 907                 break;
 908         case MS_BALL_NUKE:
 909                 if (!get_aim_dir(&dir)) return FALSE;
 910
 911         msg_print(_("Êü¼ÍÇ½µå¤òÊü¤Ã¤¿¡£", "You cast a ball of radiation."));
 912         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BA_NUKE), plev, DAM_ROLL);
 913                 fire_ball(GF_NUKE, dir, damage, 2);
 914                 break;
 915         case MS_BR_NUKE:
 916                 if (!get_aim_dir(&dir)) return FALSE;
 917
 918         msg_print(_("Êü¼ÍÀÇÑ´þÊª¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe toxic waste."));
 919         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_NUKE), plev, DAM_ROLL);
 920                 fire_ball(GF_NUKE, dir, damage, (plev > 40 ? -3 : -2));
 921                 break;
 922         case MS_BALL_CHAOS:
 923                 if (!get_aim_dir(&dir)) return FALSE;
 924
 925         msg_print(_("½ã¥í¥°¥ë¥¹¤òÊü¤Ã¤¿¡£", "You invoke a raw Logrus."));
 926         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BA_CHAO), plev, DAM_ROLL);
 927                 fire_ball(GF_CHAOS, dir, damage, 4);
 928                 break;
 929         case MS_BR_DISI:
 930                 if (!get_aim_dir(&dir)) return FALSE;
 931
 932         msg_print(_("Ê¬²ò¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", "You breathe disintegration."));
 933         damage = monspell_bluemage_damage(monspell_num(RF4_SPELL_START, RF4_BR_DISI), plev, DAM_ROLL);
 934                 fire_ball(GF_DISINTEGRATE, dir, damage, (plev > 40 ? -3 : -2));
 935                 break;
 936         case MS_BALL_ACID:
 937                 if (!get_aim_dir(&dir)) return FALSE;
 938
 939         msg_print(_("¥¢¥·¥Ã¥É¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast an acid ball."));
 940         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_ACID), plev, DAM_ROLL);
 941                 fire_ball(GF_ACID, dir, damage, 2);
 942                 break;
 943         case MS_BALL_ELEC:
 944         if (!get_aim_dir(&dir)) return FALSE;
 945
 946         msg_print(_("¥µ¥ó¥À¡¼¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a lightning ball."));
 947         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_ELEC), plev, DAM_ROLL);
 948                 fire_ball(GF_ELEC, dir, damage, 2);
 949                 break;
 950         case MS_BALL_FIRE:
 951                 if (!get_aim_dir(&dir)) return FALSE;
 952
 953         msg_print(_("¥Õ¥¡¥¤¥¢¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a fire ball."));
 954         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_FIRE), plev, DAM_ROLL);
 955                 fire_ball(GF_FIRE, dir, damage, 2);
 956                 break;
 957         case MS_BALL_COLD:
 958         if (!get_aim_dir(&dir)) return FALSE;
 959
 960         msg_print(_("¥¢¥¤¥¹¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a frost ball."));
 961         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_COLD), plev, DAM_ROLL);
 962                 fire_ball(GF_COLD, dir, damage, 2);
 963                 break;
 964         case MS_BALL_POIS:
 965                 if (!get_aim_dir(&dir)) return FALSE;
 966
 967         msg_print(_("°½±À¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a stinking cloud."));
 968         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_POIS), plev, DAM_ROLL);
 969                 fire_ball(GF_POIS, dir, damage, 2);
 970                 break;
 971         case MS_BALL_NETHER:
 972         if (!get_aim_dir(&dir)) return FALSE;
 973
 974         msg_print(_("ÃÏ¹öµå¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a nether ball."));
 975         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_NETH), plev, DAM_ROLL);
 976                 fire_ball(GF_NETHER, dir, damage, 2);
 977                 break;
 978         case MS_BALL_WATER:
 979                 if (!get_aim_dir(&dir)) return FALSE;
 980
 981         msg_print(_("Î®¤ì¤ë¤è¤¦¤Ê¿È¿¶¤ê¤ò¤·¤¿¡£", "You gesture fluidly."));
 982         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_WATE), plev, DAM_ROLL);
 983                 fire_ball(GF_WATER, dir, damage, 4);
 984                 break;
 985         case MS_BALL_MANA:
 986         if (!get_aim_dir(&dir)) return FALSE;
 987
 988         msg_print(_("ËâÎÏ¤ÎÍò¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", "You invoke a mana storm."));
 989         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_MANA), plev, DAM_ROLL);
 990                 fire_ball(GF_MANA, dir, damage, 4);
 991                 break;
 992         case MS_BALL_DARK:
 993                 if (!get_aim_dir(&dir)) return FALSE;
 994
 995         msg_print(_("°Å¹õ¤ÎÍò¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", "You invoke a darkness storm."));
 996         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_DARK), plev, DAM_ROLL);
 997                 fire_ball(GF_DARK, dir, damage, 4);
 998                 break;
 999         case MS_DRAIN_MANA:
1000                 if (!get_aim_dir(&dir)) return FALSE;
1001
1002         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_DRAIN_MANA), plev, DAM_ROLL);
1003         fire_ball_hide(GF_DRAIN_MANA, dir, damage, 0);
1004                 break;
1005         case MS_MIND_BLAST:
1006                 if (!get_aim_dir(&dir)) return FALSE;
1007
1008         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_MIND_BLAST), plev, DAM_ROLL);
1009                 fire_ball_hide(GF_MIND_BLAST, dir, damage, 0);
1010                 break;
1011         case MS_BRAIN_SMASH:
1012         if (!get_aim_dir(&dir)) return FALSE;
1013
1014         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BRAIN_SMASH), plev, DAM_ROLL);
1015                 fire_ball_hide(GF_BRAIN_SMASH, dir, damage, 0);
1016                 break;
1017         case MS_CAUSE_1:
1018                 if (!get_aim_dir(&dir)) return FALSE;
1019
1020         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_CAUSE_1), plev, DAM_ROLL);
1021                 fire_ball_hide(GF_CAUSE_1, dir, damage, 0);
1022                 break;
1023         case MS_CAUSE_2:
1024                 if (!get_aim_dir(&dir)) return FALSE;
1025
1026         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_CAUSE_2), plev, DAM_ROLL);
1027                 fire_ball_hide(GF_CAUSE_2, dir, damage, 0);
1028                 break;
1029         case MS_CAUSE_3:
1030                 if (!get_aim_dir(&dir)) return FALSE;
1031
1032         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_CAUSE_3), plev, DAM_ROLL);
1033                 fire_ball_hide(GF_CAUSE_3, dir, damage, 0);
1034                 break;
1035         case MS_CAUSE_4:
1036                 if (!get_aim_dir(&dir)) return FALSE;
1037
1038         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_CAUSE_4), plev, DAM_ROLL);
1039                 fire_ball_hide(GF_CAUSE_4, dir, damage, 0);
1040                 break;
1041         case MS_BOLT_ACID:
1042                 if (!get_aim_dir(&dir)) return FALSE;
1043
1044         msg_print(_("¥¢¥·¥Ã¥É¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast an acid bolt."));
1045         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_ACID), plev, DAM_ROLL);
1046         fire_bolt(GF_ACID, dir, damage);
1047                 break;
1048         case MS_BOLT_ELEC:
1049                 if (!get_aim_dir(&dir)) return FALSE;
1050
1051         msg_print(_("¥µ¥ó¥À¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a lightning bolt."));
1052         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_ELEC), plev, DAM_ROLL);
1053                 fire_bolt(GF_ELEC, dir, damage);
1054                 break;
1055         case MS_BOLT_FIRE:
1056                 if (!get_aim_dir(&dir)) return FALSE;
1057
1058         msg_print(_("¥Õ¥¡¥¤¥¢¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a fire bolt."));
1059         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_FIRE), plev, DAM_ROLL);
1060                 fire_bolt(GF_FIRE, dir, damage);
1061                 break;
1062         case MS_BOLT_COLD:
1063                 if (!get_aim_dir(&dir)) return FALSE;
1064
1065         msg_print(_("¥¢¥¤¥¹¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a frost bolt."));
1066         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_COLD), plev, DAM_ROLL);
1067                 fire_bolt(GF_COLD, dir, damage);
1068                 break;
1069         case MS_STARBURST:
1070                 if (!get_aim_dir(&dir)) return FALSE;
1071
1072         msg_print(_("¥¹¥¿¡¼¥Ð¡¼¥¹¥È¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", "You invoke a starburst."));
1073         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BA_LITE), plev, DAM_ROLL);
1074                 fire_ball(GF_LITE, dir, damage, 4);
1075                 break;
1076         case MS_BOLT_NETHER:
1077                 if (!get_aim_dir(&dir)) return FALSE;
1078
1079         msg_print(_("ÃÏ¹ö¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a nether bolt."));
1080         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_NETH), plev, DAM_ROLL);
1081                 fire_bolt(GF_NETHER, dir, damage);
1082                 break;
1083         case MS_BOLT_WATER:
1084                 if (!get_aim_dir(&dir)) return FALSE;
1085
1086         msg_print(_("¥¦¥©¡¼¥¿¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a water bolt."));
1087         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_WATE), plev, DAM_ROLL);
1088                 fire_bolt(GF_WATER, dir, damage);
1089                 break;
1090         case MS_BOLT_MANA:
1091                 if (!get_aim_dir(&dir)) return FALSE;
1092
1093         msg_print(_("ËâÎÏ¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a mana bolt."));
1094         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_MANA), plev, DAM_ROLL);
1095                 fire_bolt(GF_MANA, dir, damage);
1096                 break;
1097         case MS_BOLT_PLASMA:
1098                 if (!get_aim_dir(&dir)) return FALSE;
1099
1100         msg_print(_("¥×¥é¥º¥Þ¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a plasma bolt."));
1101         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_PLAS), plev, DAM_ROLL);
1102                 fire_bolt(GF_PLASMA, dir, damage);
1103                 break;
1104         case MS_BOLT_ICE:
1105                 if (!get_aim_dir(&dir)) return FALSE;
1106
1107         msg_print(_("¶Ë´¨¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a ice bolt."));
1108         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_BO_ICEE), plev, DAM_ROLL);
1109                 fire_bolt(GF_ICE, dir, damage);
1110                 break;
1111         case MS_MAGIC_MISSILE:
1112                 if (!get_aim_dir(&dir)) return FALSE;
1113
1114         msg_print(_("¥Þ¥¸¥Ã¥¯¡¦¥ß¥µ¥¤¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a magic missile."));
1115         damage = monspell_bluemage_damage(monspell_num(RF5_SPELL_START, RF5_MISSILE), plev, DAM_ROLL);
1116                 fire_bolt(GF_MISSILE, dir, damage);
1117                 break;
1118         case MS_SCARE:
1119                 if (!get_aim_dir(&dir)) return FALSE;
1120
1121         msg_print(_("¶²¤í¤·¤²¤Ê¸¸³Ð¤òºî¤ê½Ð¤·¤¿¡£", "You cast a fearful illusion."));
1122                 fear_monster(dir, plev+10);
1123                 break;
1124         case MS_BLIND:
1125                 if (!get_aim_dir(&dir)) return FALSE;
1126                 confuse_monster(dir, plev * 2);
1127                 break;
1128         case MS_CONF:
1129                 if (!get_aim_dir(&dir)) return FALSE;
1130
1131         msg_print(_("Í¶ÏÇÅª¤Ê¸¸³Ð¤ò¤Ä¤¯¤ê½Ð¤·¤¿¡£", "You cast a mesmerizing illusion."));
1132                 confuse_monster(dir, plev * 2);
1133                 break;
1134         case MS_SLOW:
1135                 if (!get_aim_dir(&dir)) return FALSE;
1136                 slow_monster(dir, plev);
1137                 break;
1138         case MS_SLEEP:
1139                 if (!get_aim_dir(&dir)) return FALSE;
1140                 sleep_monster(dir, plev);
1141                 break;
1142         case MS_SPEED:
1143                 (void)set_fast(randint1(20 + plev) + plev, FALSE);
1144                 break;
1145         case MS_HAND_DOOM:
1146         {
1147                 if (!get_aim_dir(&dir)) return FALSE;
1148
1149         msg_print(_("<ÇËÌÇ¤Î¼ê>¤òÊü¤Ã¤¿¡ª", "You invoke the Hand of Doom!"));
1150                 fire_ball_hide(GF_HAND_DOOM, dir, plev * 3, 0);
1151                 break;
1152         }
1153         case MS_HEAL:
1154         msg_print(_("¼«Ê¬¤Î½ý¤ËÇ°¤ò½¸Ãæ¤·¤¿¡£", "You concentrate on your wounds!"));
1155                 (void)hp_player(plev*4);
1156                 (void)set_stun(0);
1157                 (void)set_cut(0);
1158                 break;
1159         case MS_INVULNER:
1160         msg_print(_("Ìµ½ý¤Îµå¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a Globe of Invulnerability."));
1161                 (void)set_invuln(randint1(4) + 4, FALSE);
1162                 break;
1163         case MS_BLINK:
1164                 teleport_player(10, 0L);
1165                 break;
1166         case MS_TELEPORT:
1167                 teleport_player(plev * 5, 0L);
1168                 break;
1169         case MS_WORLD:
1170         world_player = TRUE;
1171         msg_print(_("¡Ö»þ¤è¡ª¡×", "'Time!'"));
1172                 msg_print(NULL);
1173
1174                 /* Hack */
1175                 p_ptr->energy_need -= 1000 + (100 + randint1(200)+200)*TURNS_PER_TICK/10;
1176
1177                 /* Redraw map */
1178                 p_ptr->redraw |= (PR_MAP);
1179
1180                 /* Update monsters */
1181                 p_ptr->update |= (PU_MONSTERS);
1182
1183                 /* Window stuff */
1184                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1185
1186                 handle_stuff();
1187                 break;
1188         case MS_SPECIAL:
1189                 break;
1190         case MS_TELE_TO:
1191         {
1192                 monster_type *m_ptr;
1193                 monster_race *r_ptr;
1194                 char m_name[80];
1195
1196                 if (!target_set(TARGET_KILL)) return FALSE;
1197                 if (!cave[target_row][target_col].m_idx) break;
1198                 if (!player_has_los_bold(target_row, target_col)) break;
1199                 if (!projectable(py, px, target_row, target_col)) break;
1200                 m_ptr = &m_list[cave[target_row][target_col].m_idx];
1201                 r_ptr = &r_info[m_ptr->r_idx];
1202                 monster_desc(m_name, m_ptr, 0);
1203                 if (r_ptr->flagsr & RFR_RES_TELE)
1204                 {
1205                         if ((r_ptr->flags1 & (RF1_UNIQUE)) || (r_ptr->flagsr & RFR_RES_ALL))
1206                         {
1207                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= RFR_RES_TELE;
1208                 msg_format(_("%s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª", "%s is unaffected!"), m_name);
1209                                 break;
1210                         }
1211                         else if (r_ptr->level > randint1(100))
1212                         {
1213                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= RFR_RES_TELE;
1214                 msg_format(_("%s¤Ë¤ÏÂÑÀ¤¬¤¢¤ë¡ª", "%s resists!"), m_name);
1215                                 break;
1216                         }
1217                 }
1218         msg_format(_("%s¤ò°ú¤Ìá¤·¤¿¡£", "You command %s to return."), m_name);
1219                 teleport_monster_to(cave[target_row][target_col].m_idx, py, px, 100, TELEPORT_PASSIVE);
1220                 break;
1221         }
1222         case MS_TELE_AWAY:
1223                 if (!get_aim_dir(&dir)) return FALSE;
1224
1225                 (void)fire_beam(GF_AWAY_ALL, dir, 100);
1226                 break;
1227         case MS_TELE_LEVEL:
1228         {
1229                 int target_m_idx;
1230                 monster_type *m_ptr;
1231                 monster_race *r_ptr;
1232                 char m_name[80];
1233
1234                 if (!target_set(TARGET_KILL)) return FALSE;
1235                 target_m_idx = cave[target_row][target_col].m_idx;
1236                 if (!target_m_idx) break;
1237                 if (!player_has_los_bold(target_row, target_col)) break;
1238                 if (!projectable(py, px, target_row, target_col)) break;
1239                 m_ptr = &m_list[target_m_idx];
1240                 r_ptr = &r_info[m_ptr->r_idx];
1241                 monster_desc(m_name, m_ptr, 0);
1242         msg_format(_("%^s¤ÎÂ¤ò»Ø¤µ¤·¤¿¡£", "You gesture at %^s's feet."), m_name);
1243
1244                 if ((r_ptr->flagsr & (RFR_EFF_RES_NEXU_MASK | RFR_RES_TELE)) ||
1245                         (r_ptr->flags1 & RF1_QUESTOR) || (r_ptr->level + randint1(50) > plev + randint1(60)))
1246                 {
1247             msg_format(_("¤·¤«¤·¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª", "%^s is unaffected!"), m_name);
1248                 }
1249                 else teleport_level(target_m_idx);
1250                 break;
1251         }
1252         case MS_PSY_SPEAR:
1253                 if (!get_aim_dir(&dir)) return FALSE;
1254
1255         msg_print(_("¸÷¤Î·õ¤òÊü¤Ã¤¿¡£", "You throw a psycho-spear."));
1256         damage = monspell_bluemage_damage(monspell_num(RF6_SPELL_START, RF6_PSY_SPEAR), plev, DAM_ROLL);
1257                 (void)fire_beam(GF_PSY_SPEAR, dir, damage);
1258                 break;
1259         case MS_DARKNESS:
1260
1261         msg_print(_("°Å°Ç¤ÎÃæ¤Ç¼ê¤ò¿¶¤Ã¤¿¡£", "You gesture in shadow."));
1262                 (void)unlite_area(10, 3);
1263                 break;
1264         case MS_MAKE_TRAP:
1265                 if (!target_set(TARGET_KILL)) return FALSE;
1266
1267         msg_print(_("¼öÊ¸¤ò¾§¤¨¤Æ¼Ù°¤ËÈù¾Ð¤ó¤À¡£", "You cast a spell and cackle evilly."));
1268                 trap_creation(target_row, target_col);
1269                 break;
1270         case MS_FORGET:
1271         msg_print(_("¤·¤«¤·²¿¤âµ¯¤¤Ê¤«¤Ã¤¿¡£", "Nothing happen."));
1272                 break;
1273     case MS_RAISE_DEAD:
1274         msg_print(_("»à¼ÔÉü³è¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", "You cast a animate dead."));
1275                 (void)animate_dead(0, py, px);
1276                 break;
1277         case MS_S_KIN:
1278         {
1279                 int k;
1280
1281         msg_print(_("±ç·³¤ò¾¤´¤·¤¿¡£", "You summon minions."));
1282                 for (k = 0;k < 1; k++)
1283                 {
1284                         if (summon_kin_player(summon_lev, py, px, (pet ? PM_FORCE_PET : 0L)))
1285                         {
1286                                 if (!pet) msg_print(_("¾¤´¤µ¤ì¤¿Ãç´Ö¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned fellows are angry!"));
1287                         }
1288                         else
1289                         {
1290                                 no_trump = TRUE;
1291                         }
1292                 }
1293                 break;
1294         }
1295         case MS_S_CYBER:
1296         {
1297                 int k;
1298
1299         msg_print(_("¥µ¥¤¥Ð¡¼¥Ç¡¼¥â¥ó¤ò¾¤´¤·¤¿¡ª", "You summon a Cyberdemon!"));
1300                 for (k = 0 ;k < 1 ; k++)
1301                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_CYBER, p_mode))
1302                         {
1303                 if (!pet)
1304                     msg_print(_("¾¤´¤µ¤ì¤¿¥µ¥¤¥Ð¡¼¥Ç¡¼¥â¥ó¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "The summoned Cyberdemon are angry!"));
1305                         }
1306                         else
1307                         {
1308                                 no_trump = TRUE;
1309                         }
1310                 break;
1311         }
1312         case MS_S_MONSTER:
1313         {
1314                 int k;
1315         msg_print(_("Ãç´Ö¤ò¾¤´¤·¤¿¡£", "You summon help."));
1316                 for (k = 0;k < 1; k++)
1317                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, 0, p_mode))
1318                         {
1319                 if (!pet)
1320                     msg_print(_("¾¤´¤µ¤ì¤¿¥â¥ó¥¹¥¿¡¼¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "The summoned monster is angry!"));
1321                         }
1322                         else
1323                         {
1324                                 no_trump = TRUE;
1325                         }
1326                 break;
1327         }
1328         case MS_S_MONSTERS:
1329         {
1330                 int k;
1331         msg_print(_("¥â¥ó¥¹¥¿¡¼¤ò¾¤´¤·¤¿¡ª", "You summon monsters!"));
1332                 for (k = 0;k < plev / 15 + 2; k++)
1333                         if(summon_specific((pet ? -1 : 0), py, px, summon_lev, 0, (p_mode | u_mode)))
1334                         {
1335                 if (!pet)
1336                     msg_print(_("¾¤´¤µ¤ì¤¿¥â¥ó¥¹¥¿¡¼¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "The summoned monsters are angry!"));
1337                         }
1338                         else
1339                         {
1340                                 no_trump = TRUE;
1341                         }
1342                 break;
1343         }
1344         case MS_S_ANT:
1345         {
1346                 int k;
1347         msg_print(_("¥¢¥ê¤ò¾¤´¤·¤¿¡£", "You summon ants."));
1348                 for (k = 0;k < 1; k++)
1349                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_ANT, (PM_ALLOW_GROUP | p_mode)))
1350                         {
1351                 if (!pet)
1352                     msg_print(_("¾¤´¤µ¤ì¤¿¥¢¥ê¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "The summoned ants are angry!"));
1353                         }
1354                         else
1355                         {
1356                                 no_trump = TRUE;
1357                         }
1358                 break;
1359         }
1360         case MS_S_SPIDER:
1361         {
1362                 int k;
1363         msg_print(_("ÃØéá¤ò¾¤´¤·¤¿¡£", "You summon spiders."));
1364                 for (k = 0;k < 1; k++)
1365                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_SPIDER, (PM_ALLOW_GROUP | p_mode)))
1366                         {
1367                 if (!pet)
1368                     msg_print(_("¾¤´¤µ¤ì¤¿ÃØéá¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned spiders are angry!"));
1369                         }
1370                         else
1371                         {
1372                                 no_trump = TRUE;
1373                         }
1374                 break;
1375         }
1376         case MS_S_HOUND:
1377         {
1378                 int k;
1379         msg_print(_("¥Ï¥¦¥ó¥É¤ò¾¤´¤·¤¿¡£", "You summon hounds."));
1380                 for (k = 0;k < 1; k++)
1381                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_HOUND, (PM_ALLOW_GROUP | p_mode)))
1382                         {
1383                 if (!pet)
1384                     msg_print(_("¾¤´¤µ¤ì¤¿¥Ï¥¦¥ó¥É¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned hounds are angry!"));
1385                         }
1386                         else
1387                         {
1388                                 no_trump = TRUE;
1389                         }
1390                 break;
1391         }
1392         case MS_S_HYDRA:
1393         {
1394                 int k;
1395         msg_print(_("¥Ò¥É¥é¤ò¾¤´¤·¤¿¡£", "You summon a hydras."));
1396                 for (k = 0;k < 1; k++)
1397                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_HYDRA, (g_mode | p_mode)))
1398                         {
1399                 if (!pet)
1400                     msg_print(_("¾¤´¤µ¤ì¤¿¥Ò¥É¥é¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned hydras are angry!"));
1401                         }
1402                         else
1403                         {
1404                                 no_trump = TRUE;
1405                         }
1406                 break;
1407         }
1408         case MS_S_ANGEL:
1409         {
1410                 int k;
1411         msg_print(_("Å·»È¤ò¾¤´¤·¤¿¡ª", "You summon an angel!"));
1412                 for (k = 0;k < 1; k++)
1413                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_ANGEL, (g_mode | p_mode)))
1414                         {
1415                 if (!pet)
1416                     msg_print(_("¾¤´¤µ¤ì¤¿Å·»È¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned angels are angry!"));
1417                         }
1418                         else
1419                         {
1420                                 no_trump = TRUE;
1421                         }
1422                 break;
1423         }
1424         case MS_S_DEMON:
1425         {
1426                 int k;
1427         msg_print(_("º®ÆÙ¤ÎµÜÄî¤«¤é°Ëâ¤ò¾¤´¤·¤¿¡ª", "You summon a demon from the Courts of Chaos!"));
1428                 for (k = 0;k < 1; k++)
1429                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_DEMON, (g_mode | p_mode)))
1430                         {
1431                 if (!pet)
1432                     msg_print(_("¾¤´¤µ¤ì¤¿¥Ç¡¼¥â¥ó¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned demons are angry!"));
1433                         }
1434                         else
1435                         {
1436                                 no_trump = TRUE;
1437                         }
1438                 break;
1439         }
1440         case MS_S_UNDEAD:
1441         {
1442                 int k;
1443         msg_print(_("¥¢¥ó¥Ç¥Ã¥É¤Î¶¯Å¨¤ò¾¤´¤·¤¿¡ª", "You summon an undead adversary!"));
1444                 for (k = 0;k < 1; k++)
1445                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_UNDEAD, (g_mode | p_mode)))
1446                         {
1447                 if (!pet)
1448                     msg_print(_("¾¤´¤µ¤ì¤¿¥¢¥ó¥Ç¥Ã¥É¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned undeads are angry!"));
1449                         }
1450                         else
1451                         {
1452                                 no_trump = TRUE;
1453                         }
1454                 break;
1455         }
1456         case MS_S_DRAGON:
1457         {
1458                 int k;
1459         msg_print(_("¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", "You summon a dragon!"));
1460                 for (k = 0;k < 1; k++)
1461                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_DRAGON, (g_mode | p_mode)))
1462                         {
1463                 if (!pet)
1464                     msg_print(_("¾¤´¤µ¤ì¤¿¥É¥é¥´¥ó¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned dragons are angry!"));
1465                         }
1466                         else
1467                         {
1468                                 no_trump = TRUE;
1469                         }
1470                 break;
1471         }
1472         case MS_S_HI_UNDEAD:
1473         {
1474                 int k;
1475         msg_print(_("¶¯ÎÏ¤Ê¥¢¥ó¥Ç¥Ã¥É¤ò¾¤´¤·¤¿¡ª", "You summon a greater undead!"));
1476                 for (k = 0;k < 1; k++)
1477                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_HI_UNDEAD, (g_mode | p_mode | u_mode)))
1478                         {
1479                 if (!pet)
1480                     msg_print(_("¾¤´¤µ¤ì¤¿¾åµé¥¢¥ó¥Ç¥Ã¥É¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned greater undeads are angry!"));
1481                         }
1482                         else
1483                         {
1484                                 no_trump = TRUE;
1485                         }
1486                 break;
1487         }
1488         case MS_S_HI_DRAGON:
1489         {
1490                 int k;
1491         msg_print(_("¸ÅÂå¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", "You summon an ancient dragon!"));
1492                 for (k = 0;k < 1; k++)
1493                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_HI_DRAGON, (g_mode | p_mode | u_mode)))
1494                         {
1495                 if (!pet)
1496                     msg_print(_("¾¤´¤µ¤ì¤¿¸ÅÂå¥É¥é¥´¥ó¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned ancient dragons are angry!"));
1497                         }
1498                         else
1499                         {
1500                                 no_trump = TRUE;
1501                         }
1502                 break;
1503         }
1504         case MS_S_AMBERITE:
1505         {
1506                 int k;
1507         msg_print(_("¥¢¥ó¥Ð¡¼¤Î²¦Â²¤ò¾¤´¤·¤¿¡ª", "You summon a Lord of Amber!"));
1508                 for (k = 0;k < 1; k++)
1509                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_AMBERITES, (g_mode | p_mode | u_mode)))
1510                         {
1511                 if (!pet)
1512                     msg_print(_("¾¤´¤µ¤ì¤¿¥¢¥ó¥Ð¡¼¤Î²¦Â²¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned Lords of Amber are angry!"));
1513                         }
1514                         else
1515                         {
1516                                 no_trump = TRUE;
1517                         }
1518                 break;
1519         }
1520         case MS_S_UNIQUE:
1521         {
1522                 int k, count = 0;
1523         msg_print(_("ÆÃÊÌ¤Ê¶¯Å¨¤ò¾¤´¤·¤¿¡ª", "You summon a special opponent!"));
1524                 for (k = 0;k < 1; k++)
1525                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_UNIQUE, (g_mode | p_mode | PM_ALLOW_UNIQUE)))
1526                         {
1527                                 count++;
1528                 if (!pet)
1529                     msg_print(_("¾¤´¤µ¤ì¤¿¥æ¥Ë¡¼¥¯¡¦¥â¥ó¥¹¥¿¡¼¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned special opponents are angry!"));
1530                         }
1531                 for (k = count;k < 1; k++)
1532                         if (summon_specific((pet ? -1 : 0), py, px, summon_lev, SUMMON_HI_UNDEAD, (g_mode | p_mode | PM_ALLOW_UNIQUE)))
1533                         {
1534                                 count++;
1535                 if (!pet)
1536                     msg_print(_("¾¤´¤µ¤ì¤¿¾åµé¥¢¥ó¥Ç¥Ã¥É¤ÏÅÜ¤Ã¤Æ¤¤¤ë¡ª", "Summoned greater undeads are angry!"));
1537                         }
1538                 if (!count)
1539                 {
1540                         no_trump = TRUE;
1541                 }
1542                 break;
1543         }
1544         default:
1545                 msg_print("hoge?");
1546         }
1547         if (no_trump)
1548     {
1549         msg_print(_("²¿¤â¸½¤ì¤Ê¤«¤Ã¤¿¡£", "No one have appeared."));
1550         }
1551
1552         return TRUE;
1553 }
1554
1555 /*!
1556  * @brief ÀÄËâË¡¥³¥Þ¥ó¥É¤Î¥á¥¤¥ó¥ë¡¼¥Á¥ó /
1557  * do_cmd_cast calls this function if the player's class is 'Blue-Mage'.
1558  * @return ½èÍý¤ò¼Â¹Ô¤·¤¿¤éTRUE¡¢¥¥ã¥ó¥»¥ë¤·¤¿¾ì¹çFALSE¤òÊÖ¤¹¡£
1559  */
1560 bool do_cmd_cast_learned(void)
1561 {
1562         int             n = 0;
1563         int             chance;
1564         int             minfail = 0;
1565         int             plev = p_ptr->lev;
1566         monster_power   spell;
1567         bool            cast;
1568         int             need_mana;
1569
1570
1571         /* not if confused */
1572         if (p_ptr->confused)
1573         {
1574 #ifdef JP
1575 msg_print("º®Íð¤·¤Æ¤¤¤Æ¾§¤¨¤é¤ì¤Ê¤¤¡ª");
1576 #else
1577                 msg_print("You are too confused!");
1578 #endif
1579
1580                 return TRUE;
1581         }
1582
1583         /* get power */
1584         if (!get_learned_power(&n)) return FALSE;
1585
1586         spell = monster_powers[n];
1587
1588         need_mana = mod_need_mana(spell.smana, 0, REALM_NONE);
1589
1590         /* Verify "dangerous" spells */
1591         if (need_mana > p_ptr->csp)
1592         {
1593                 /* Warning */
1594 #ifdef JP
1595 msg_print("£Í£Ð¤¬Â¤ê¤Þ¤»¤ó¡£");
1596 #else
1597                 msg_print("You do not have enough mana to use this power.");
1598 #endif
1599
1600
1601                 if (!over_exert) return FALSE;
1602
1603                 /* Verify */
1604 #ifdef JP
1605 if (!get_check("¤½¤ì¤Ç¤âÄ©Àï¤·¤Þ¤¹¤«? ")) return FALSE;
1606 #else
1607                 if (!get_check("Attempt it anyway? ")) return FALSE;
1608 #endif
1609
1610         }
1611
1612         /* Spell failure chance */
1613         chance = spell.fail;
1614
1615         /* Reduce failure rate by "effective" level adjustment */
1616         if (plev > spell.level) chance -= 3 * (plev - spell.level);
1617         else chance += (spell.level - plev);
1618
1619         /* Reduce failure rate by INT/WIS adjustment */
1620         chance -= 3 * (adj_mag_stat[p_ptr->stat_ind[A_INT]] - 1);
1621
1622         chance = mod_spell_chance_1(chance);
1623
1624         /* Not enough mana to cast */
1625         if (need_mana > p_ptr->csp)
1626         {
1627                 chance += 5 * (need_mana - p_ptr->csp);
1628         }
1629
1630         /* Extract the minimum failure rate */
1631         minfail = adj_mag_fail[p_ptr->stat_ind[A_INT]];
1632
1633         /* Minimum failure rate */
1634         if (chance < minfail) chance = minfail;
1635
1636         /* Stunning makes spells harder */
1637         if (p_ptr->stun > 50) chance += 25;
1638         else if (p_ptr->stun) chance += 15;
1639
1640         /* Always a 5 percent chance of working */
1641         if (chance > 95) chance = 95;
1642
1643         chance = mod_spell_chance_2(chance);
1644
1645         /* Failed spell */
1646         if (randint0(100) < chance)
1647         {
1648                 if (flush_failure) flush();
1649 #ifdef JP
1650 msg_print("ËâË¡¤ò¤¦¤Þ¤¯¾§¤¨¤é¤ì¤Ê¤«¤Ã¤¿¡£");
1651 #else
1652                 msg_print("You failed to concentrate hard enough!");
1653 #endif
1654
1655                 sound(SOUND_FAIL);
1656
1657                 if (n >= MS_S_KIN)
1658                         /* Cast the spell */
1659                         cast = cast_learned_spell(n, FALSE);
1660         }
1661         else
1662         {
1663                 sound(SOUND_ZAP);
1664
1665                 /* Cast the spell */
1666                 cast = cast_learned_spell(n, TRUE);
1667
1668                 if (!cast) return FALSE;
1669         }
1670
1671         /* Sufficient mana */
1672         if (need_mana <= p_ptr->csp)
1673         {
1674                 /* Use some mana */
1675                 p_ptr->csp -= need_mana;
1676         }
1677         else
1678         {
1679                 int oops = need_mana;
1680
1681                 /* No mana left */
1682                 p_ptr->csp = 0;
1683                 p_ptr->csp_frac = 0;
1684
1685                 /* Message */
1686 #ifdef JP
1687 msg_print("Àº¿À¤ò½¸Ãæ¤·¤¹¤®¤Æµ¤¤ò¼º¤Ã¤Æ¤·¤Þ¤Ã¤¿¡ª");
1688 #else
1689                 msg_print("You faint from the effort!");
1690 #endif
1691
1692
1693                 /* Hack -- Bypass free action */
1694                 (void)set_paralyzed(p_ptr->paralyzed + randint1(5 * oops + 1));
1695
1696                 chg_virtue(V_KNOWLEDGE, -10);
1697
1698                 /* Damage CON (possibly permanently) */
1699                 if (randint0(100) < 50)
1700                 {
1701                         bool perm = (randint0(100) < 25);
1702
1703                         /* Message */
1704 #ifdef JP
1705 msg_print("ÂÎ¤ò°¤¯¤·¤Æ¤·¤Þ¤Ã¤¿¡ª");
1706 #else
1707                         msg_print("You have damaged your health!");
1708 #endif
1709
1710
1711                         /* Reduce constitution */
1712                         (void)dec_stat(A_CON, 15 + randint1(10), perm);
1713                 }
1714         }
1715
1716         /* Take a turn */
1717         energy_use = 100;
1718
1719         /* Window stuff */
1720         p_ptr->redraw |= (PR_MANA);
1721         p_ptr->window |= (PW_PLAYER);
1722         p_ptr->window |= (PW_SPELL);
1723
1724         return TRUE;
1725 }
1726
1727 /*!
1728  * @brief ÀÄËâË¡¤Î¥é¡¼¥Ë¥ó¥°È½Äê¤ÈÀ®¸ù¤·¤¿¾ì¹ç¤Î¥é¡¼¥Ë¥ó¥°½èÍý
1729  * @param monspell ¥é¡¼¥Ë¥ó¥°¤ò»î¤ß¤ë¥â¥ó¥¹¥¿¡¼¹¶·â¤ÎID
1730  * @return ¤Ê¤·
1731  */
1732 void learn_spell(int monspell)
1733 {
1734         if (p_ptr->action != ACTION_LEARN) return;
1735         if (monspell < 0) return; /* Paranoia */
1736         if (p_ptr->magic_num2[monspell]) return;
1737         if (p_ptr->confused || p_ptr->blind || p_ptr->image || p_ptr->stun || p_ptr->paralyzed) return;
1738         if (randint1(p_ptr->lev + 70) > monster_powers[monspell].level + 40)
1739         {
1740                 p_ptr->magic_num2[monspell] = 1;
1741 #ifdef JP
1742                 msg_format("%s¤ò³Ø½¬¤·¤¿¡ª", monster_powers[monspell].name);
1743 #else
1744                 msg_format("You have learned %s!", monster_powers[monspell].name);
1745 #endif
1746                 gain_exp(monster_powers[monspell].level * monster_powers[monspell].smana);
1747
1748                 /* Sound */
1749                 sound(SOUND_STUDY);
1750
1751                 new_mane = TRUE;
1752                 p_ptr->redraw |= (PR_STATE);
1753         }
1754 }
1755
1756
1757 /*!
1758  * @brief ¥â¥ó¥¹¥¿¡¼ÆÃ¼ìÇ½ÎÏ¤Î¥Õ¥é¥°ÇÛÎó¤«¤éÆÃÄê¾ò·ï¤ÎËâË¡¤À¤±¤òÈ´¤½Ð¤¹½èÍý
1759  * Extract monster spells mask for the given mode
1760  * @param f4 ¥â¥ó¥¹¥¿¡¼ÆÃ¼ìÇ½ÎÏ¤Î4ÈÖÌÜ¤Î¥Õ¥é¥°ÇÛÎó
1761  * @param f5 ¥â¥ó¥¹¥¿¡¼ÆÃ¼ìÇ½ÎÏ¤Î5ÈÖÌÜ¤Î¥Õ¥é¥°ÇÛÎó
1762  * @param f6 ¥â¥ó¥¹¥¿¡¼ÆÃ¼ìÇ½ÎÏ¤Î6ÈÖÌÜ¤Î¥Õ¥é¥°ÇÛÎó
1763  * @param mode È´¤½Ð¤·¤¿¤¤¾ò·ï
1764  * @return ¤Ê¤·
1765  */
1766 /*
1767  */
1768 void set_rf_masks(s32b *f4, s32b *f5, s32b *f6, int mode)
1769 {
1770         switch (mode)
1771         {
1772                 case MONSPELL_TYPE_BOLT:
1773                         *f4 = ((RF4_BOLT_MASK | RF4_BEAM_MASK) & ~(RF4_ROCKET));
1774                         *f5 = RF5_BOLT_MASK | RF5_BEAM_MASK;
1775                         *f6 = RF6_BOLT_MASK | RF6_BEAM_MASK;
1776                         break;
1777
1778                 case MONSPELL_TYPE_BALL:
1779                         *f4 = (RF4_BALL_MASK & ~(RF4_BREATH_MASK));
1780                         *f5 = (RF5_BALL_MASK & ~(RF5_BREATH_MASK));
1781                         *f6 = (RF6_BALL_MASK & ~(RF6_BREATH_MASK));
1782                         break;
1783
1784                 case MONSPELL_TYPE_BREATH:
1785                         *f4 = RF4_BREATH_MASK;
1786                         *f5 = RF5_BREATH_MASK;
1787                         *f6 = RF6_BREATH_MASK;
1788                         break;
1789
1790                 case MONSPELL_TYPE_SUMMON:
1791                         *f4 = RF4_SUMMON_MASK;
1792                         *f5 = RF5_SUMMON_MASK;
1793                         *f6 = RF6_SUMMON_MASK;
1794                         break;
1795
1796                 case MONSPELL_TYPE_OTHER:
1797                         *f4 = RF4_ATTACK_MASK & ~(RF4_BOLT_MASK | RF4_BEAM_MASK | RF4_BALL_MASK | RF4_INDIRECT_MASK);
1798                         *f5 = RF5_ATTACK_MASK & ~(RF5_BOLT_MASK | RF5_BEAM_MASK | RF5_BALL_MASK | RF5_INDIRECT_MASK);
1799                         *f6 = RF6_ATTACK_MASK & ~(RF6_BOLT_MASK | RF6_BEAM_MASK | RF6_BALL_MASK | RF6_INDIRECT_MASK);
1800                         break;
1801         }
1802
1803         return;
1804 }