src/mind.c

   1 /* File: mind.c */
   2
   3 /*
   4  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   5  *
   6  * This software may be copied and distributed for educational, research,
   7  * and not for profit purposes provided that this copyright and statement
   8  * are included in all such copies.  Other copyrights may also apply.
   9  */
  10
  11 /* Purpose: Mindcrafter code */
  12
  13 #include "angband.h"
  14 #include "mindtips.h"
  15
  16
  17 mind_power mind_powers[5] =
  18 {
  19   {
  20     {
  21       /* Level gained,  cost,  %fail,  name */
  22 #ifdef JP
  23       { 1,   1,  15, "Îî»ë"},
  24       { 2,   1,  20, "¿À·Ð¹¶·â"},
  25       { 3,   2,  25, "¼¡¸µ¤Î½Ö¤"},
  26       { 7,   6,  35, "µõ¶õ¤Î¸¸±Æ"},
  27       { 9,   7,  50, "Àº¿À»ÙÇÛ"},
  28       { 11,  7,  30, "Ç°Æ°¾×·âÃÆ"},
  29       { 13, 12,  50, "³»²½"},
  30       { 15, 12,  60, "¥µ¥¤¥³¥á¥È¥ê¡¼"},
  31       { 18, 10,  45, "Àº¿ÀÇÈÆ°"},
  32       { 23, 15,  50, "¥¢¥É¥ì¥Ê¥ê¥ó¡¦¥É¡¼¥Ô¥ó¥°"},
  33       { 26, 28,  60, "¥Æ¥ì¥¥Í¥·¥¹"},
  34       { 28, 10,  40, "¥µ¥¤¥¥Ã¥¯¡¦¥É¥ì¥¤¥ó"},
  35       { 35, 35,  75, "¸÷¤Î·õ"},
  36       { 45,150,  85, "´°Á´¤ÊÀ¤³¦"},
  37       { 99,  0,   0, ""},
  38       { 99,  0,   0, ""},
  39       { 99,  0,   0, ""},
  40       { 99,  0,   0, ""},
  41       { 99,  0,   0, ""},
  42       { 99,  0,   0, ""},
  43       { 99,  0,   0, ""},
  44 #else
  45       { 1,   1,  15, "Precognition"},
  46       { 2,   1,  20, "Neural Blast"},
  47       { 3,   2,  25, "Minor Displacement"},
  48       { 7,   6,  35, "Major Displacement"},
  49       { 9,   7,  50, "Domination"},
  50       { 11,  7,  30, "Pulverise"},
  51       { 13, 12,  50, "Character Armour"},
  52       { 15, 12,  60, "Psychometry" },
  53       { 18, 10,  45, "Mind Wave" },
  54       { 23, 15,  50, "Adrenaline Channeling"},
  55       { 26, 28,  60, "Telekinesis"},
  56       { 28, 10,  40, "Psychic Drain"},
  57       { 35, 35,  75, "Psycho-Spear"},
  58       { 45,150,  85, "The World"},
  59       { 99,  0,   0, ""},
  60       { 99,  0,   0, ""},
  61       { 99,  0,   0, ""},
  62       { 99,  0,   0, ""},
  63       { 99,  0,   0, ""},
  64       { 99,  0,   0, ""},
  65       { 99,  0,   0, ""},
  66 #endif
  67
  68     }
  69   },
  70
  71   {
  72     {
  73       /* Level gained,  cost,  %fail,  name */
  74 #ifdef JP
  75       { 1,   1,  15, "¾®Î¶"},
  76       { 3,   3,  30, "Á®¸÷"},
  77       { 5,   6,  35, "Éñ¶õ½Ñ"},
  78       { 8,   5,  40, "¥«¥á¥Ï¥áÇÈ"},
  79       { 10,  7,  45, "ÂÐËâË¡ËÉ¸æ"},
  80       { 13,  5,  60, "Îýµ¤"},
  81       { 17, 17,  50, "Å»Æ®µ¤"},
  82       { 20, 20,  50, "¾×ÇÈ"},
  83       { 23, 18,  55, "×ÂÎ¶"},
  84       { 25, 30,  70, "¤¤¤Æ¤Ä¤¯ÇÈÆ°"},
  85       { 28, 26,  50, "¸¸Îî¾¤´"},
  86       { 32, 35,  65, "Îû¹ö²Ð±ê"},
  87       { 38, 42,  75, "Ä¶¥«¥á¥Ï¥áÇÈ"},
  88       { 44, 50,  80, "¸÷Â®°ÜÆ°"},
  89       { 99,  0,   0, ""},
  90       { 99,  0,   0, ""},
  91       { 99,  0,   0, ""},
  92       { 99,  0,   0, ""},
  93       { 99,  0,   0, ""},
  94       { 99,  0,   0, ""},
  95       { 99,  0,   0, ""},
  96 #else
  97       { 1,   1,  15, "Small Force Ball"},
  98       { 3,   3,  30, "Flash Light"},
  99       { 5,   6,  35, "Flying Technique"},
 100       { 8,   5,  40, "Kamehameha"},
 101       { 10,  7,  45, "Magic Resistance"},
 102       { 13,  5,  60, "Improve Force"},
 103       { 17, 17,  50, "Aura of Force"},
 104       { 20, 20,  50, "Shock Power"},
 105       { 23, 18,  55, "Large Force Ball"},
 106       { 25, 30,  70, "Dispel Magic"},
 107       { 28, 26,  50, "Summon Ghost"},
 108       { 32, 35,  65, "Exploding Frame"},
 109       { 38, 42,  75, "Super Kamehameha"},
 110       { 44, 50,  80, "Light Speed"},
 111       { 99,  0,   0, ""},
 112       { 99,  0,   0, ""},
 113       { 99,  0,   0, ""},
 114       { 99,  0,   0, ""},
 115       { 99,  0,   0, ""},
 116       { 99,  0,   0, ""},
 117       { 99,  0,   0, ""},
 118 #endif
 119
 120     }
 121   },
 122
 123   {
 124     {
 125       /* Level gained,  cost,  %fail,  name */
 126 #ifdef JP
 127       {  8,  5,  40, "»¦µ¤´¶ÃÎ"},
 128       { 15, 20,   0, "ÆÍ·â"},
 129       { 20, 15,   0, "¥È¥é¥Ã¥×Ê´ºÕ"},
 130       { 25, 20,  60, "ÃÏ¿Ì"},
 131       { 30, 80,  75, "³§»¦¤·"},
 132       { 99,  0,   0, ""},
 133       { 99,  0,   0, ""},
 134       { 99,  0,   0, ""},
 135       { 99,  0,   0, ""},
 136       { 99,  0,   0, ""},
 137       { 99,  0,   0, ""},
 138       { 99,  0,   0, ""},
 139       { 99,  0,   0, ""},
 140       { 99,  0,   0, ""},
 141       { 99,  0,   0, ""},
 142       { 99,  0,   0, ""},
 143       { 99,  0,   0, ""},
 144       { 99,  0,   0, ""},
 145       { 99,  0,   0, ""},
 146       { 99,  0,   0, ""},
 147       { 99,  0,   0, ""},
 148 #else
 149       {  8,  5,  40, "Detect Atmosphere of Menace"},
 150       { 15, 20,   0, "Charge"},
 151       { 20, 15,   0, "Smash a Trap"},
 152       { 25, 20,  60, "Quake"},
 153       { 30, 80,  75, "Massacre"},
 154       { 99,  0,   0, ""},
 155       { 99,  0,   0, ""},
 156       { 99,  0,   0, ""},
 157       { 99,  0,   0, ""},
 158       { 99,  0,   0, ""},
 159       { 99,  0,   0, ""},
 160       { 99,  0,   0, ""},
 161       { 99,  0,   0, ""},
 162       { 99,  0,   0, ""},
 163       { 99,  0,   0, ""},
 164       { 99,  0,   0, ""},
 165       { 99,  0,   0, ""},
 166       { 99,  0,   0, ""},
 167       { 99,  0,   0, ""},
 168       { 99,  0,   0, ""},
 169       { 99,  0,   0, ""},
 170 #endif
 171
 172     }
 173   },
 174
 175   {
 176     {
 177       /* Level gained,  cost,  %fail,  name */
 178 #ifdef JP
 179       { 1,   1,  15, "¿¿¸«¤Î¶À"},
 180       { 1,   2,  40, "¶ÀÀ¸À®"},
 181       { 2,   2,  20, "¸÷¤Î¤·¤º¤¯"},
 182       { 3,   2,  20, "ÏÄ¤ó¤À¶À"},
 183       { 5,   3,  35, "Á®¸÷¶À"},
 184       { 6,   5,  35, "×Ç¤¨¤ë¶À"},
 185
 186       { 10,  5,  30, "Èù¿Ð±£¤ì"},
 187       { 12, 12,  30, "ÄÉÊü¤Î¶À"},
 188       { 15, 15,  30, "¶ÀºÕ¤"},
 189       { 19, 13,  30, "ºÅÌ²¶À"},
 190       { 23, 18,  50, "¥·¡¼¥«¡¼¥ì¥¤"},
 191
 192       { 25, 20,  40, "¶À¤ÎÉõ°õ"},
 193       { 27, 30,  60, "¿å¶À¤Î½â"},
 194       { 29, 30,  60, "¥¹¡¼¥Ñ¡¼¥ì¥¤"},
 195       { 31, 35,  60, "¸¸ÏÇ¤Î¸÷"},
 196       { 33, 50,  80, "¶À¤Î¹ñ"},
 197
 198       { 36, 30,  80, "¶ÀÈ´¤±"},
 199       { 38, 40,  70, "µ¢´Ô¤Î¶À"},
 200       { 40, 50,  55, "±ÆÊ¬¿È"},
 201       { 43, 55,  70, "ÉõËâ·ë³¦"},
 202       { 46, 70,  75, "¥é¥Õ¥Î¡¼¥ë¤Î¶À"},
 203 #else
 204       { 1,   1,  15, "Mirror of Seeing"},
 205       { 1,   2,  40, "Making a Mirror"},
 206       { 2,   2,  20, "Drip of Light"},
 207       { 3,   2,  20, "Warped Mirror"},
 208       { 5,   3,  35, "Mirror of Light"},
 209       { 6,   5,  35, "Mirror of Wandering"},
 210
 211       { 10,  5,  30, "Robe of Dust"},
 212       { 12, 12,  30, "Banishing Mirror"},
 213       { 15, 15,  30, "Mirror Clashing"},
 214       { 19, 13,  30, "Mirror Sleeping"},
 215       { 23, 18,  50, "Seeker Ray"},
 216
 217       { 25, 20,  40, "Seal of Mirror"},
 218       { 27, 30,  60, "Shield of Water"},
 219       { 29, 30,  60, "Super Ray"},
 220       { 31, 35,  60, "Illusion Light"},
 221       { 33, 50,  80, "Mirror Shift"},
 222
 223       { 36, 30,  80, "Mirror Tunnel"},
 224       { 38, 40,  70, "Mirror of Recall"},
 225       { 40, 50,  55, "Multi-Shadow"},
 226       { 43, 55,  70, "Binding Field"},
 227       { 46, 70,  75, "Mirror of Ruffnor"},
 228 #endif
 229
 230     }
 231   },
 232
 233   {
 234     {
 235       /* Level gained,  cost,  %fail,  name */
 236 #ifdef JP
 237       {  1,  1,  20, "°Å°ÇÀ¸À®"},
 238       {  2,  2,  25, "¼þÊÕÄ´ºº"},
 239       {  3,  3,  25, "ÍÕ±£¤ì"},
 240       {  5,  3,  30, "ÊÑ¤ï¤ê¿È"},
 241       {  7,  8,  35, "¹âÈô¤Ó"},
 242       {  8, 10,  35, "°ì·âÎ¥Ã¦"},
 243       { 10, 10,  40, "¶âÇû¤ê"},
 244       { 12, 12,  70, "¸Å¤Î¸ýÅÁ"},
 245       { 15, 10,  50, "Éâ±À"},
 246       { 17, 12,  45, "²ÐÆÛ"},
 247       { 18, 20,  40, "Æþ¿È"},
 248       { 20,  5,  50, "È¬Êý¼êÎ¢·õ"},
 249       { 22, 15,  55, "º¿³ù"},
 250       { 25, 32,  60, "±ì¶Ì"},
 251       { 28, 32,  60, "Å¾¿È"},
 252       { 30, 30,  70, "ÇúÈ¯¤ÎÌæ¾Ï"},
 253       { 32, 40,  40, "ÅÚÆÛ"},
 254       { 34, 35,  50, "Ì¸±£¤ì"},
 255       { 38, 40,  60, "Îû¹ö²Ð±ê"},
 256       { 41, 50,  55, "Ê¬¿È"},
 257       { 99,  0,   0, ""},
 258 #else
 259       {  1,  1,  20, "Create Darkness"},
 260       {  2,  2,  25, "Detect Near"},
 261       {  3,  3,  25, "Hide in Leafs"},
 262       {  5,  3,  30, "Kawarimi"},
 263       {  7,  8,  35, "Absconding"},
 264       {  8, 10,  35, "Hit and Away"},
 265       { 10, 10,  40, "Bind Monster"},
 266       { 12, 12,  70, "Ancient Knowledge"},
 267       { 15, 10,  50, "Floating"},
 268       { 17, 12,  45, "Hide in Flame"},
 269       { 18, 20,  40, "Nyusin"},
 270       { 20,  5,  50, "Syuriken Spreading"},
 271       { 22, 15,  55, "Chain Hook"},
 272       { 25, 32,  60, "Smoke Ball"},
 273       { 28, 32,  60, "Swap Position"},
 274       { 30, 30,  70, "Glyph of Explosion"},
 275       { 32, 40,  40, "Hide in Mud"},
 276       { 34, 35,  50, "Hide in Mist"},
 277       { 38, 40,  60, "Rengoku-Kaen"},
 278       { 41, 50,  55, "Bunshin"},
 279       { 99,  0,   0, ""},
 280 #endif
 281
 282     }
 283   },
 284 };
 285
 286
 287 void mindcraft_info(char *p, int use_mind, int power)
 288 {
 289 #ifdef JP
 290         cptr s_dam = "Â»½ý:";
 291         cptr s_dur = "´ü´Ö:";
 292         cptr s_range = "ÈÏ°Ï:";
 293 #else
 294         cptr s_dam = "dam ";
 295         cptr s_dur = "dur ";
 296         cptr s_range = "range ";
 297 #endif
 298   int plev = p_ptr->lev;
 299
 300   strcpy(p, "");
 301
 302   switch (use_mind)
 303     {
 304     case MIND_MINDCRAFTER:
 305       switch (power)
 306         {
 307         case 0:  break;
 308         case 1:  sprintf(p, " %s%dd%d", s_dam, 3 + ((plev - 1) / 4), 3 + plev/15); break;
 309         case 2:  sprintf(p, " %s10", s_range); break;
 310         case 3:  sprintf(p, " %s%d", s_range, plev * 5);  break;
 311         case 4:  break;
 312         case 5: sprintf(p, " %s%dd8", s_dam, 8 + ((plev - 5) / 4));  break;
 313         case 6:  sprintf(p, " %s%d", s_dur, plev);  break;
 314         case 7:  break;
 315         case 8:  sprintf(p, (plev < 25 ? " %s%d" : " %sd%d"), s_dam, (plev < 25 ? plev * 3 / 2 : plev * ((plev - 5) / 10 + 1))); break;
 316         case 9:  sprintf(p, " %s10+d%d", s_dur, plev * 3 / 2);  break;
 317 #ifdef JP
 318         case 10: sprintf(p, " ºÇÂç½ÅÎÌ:%d.%dkg", lbtokg1(plev * 15),lbtokg2(plev * 15));  break;
 319 #else
 320         case 10: sprintf(p, " max wgt %d", plev * 15);  break;
 321 #endif
 322         case 11: sprintf(p, " %s%dd6", s_dam, plev / 2);  break;
 323         case 12: sprintf(p, " %sd%d+%d", s_dam, plev * 3, plev * 3); break;
 324 #ifdef JP
 325         case 13: sprintf(p, " ¹ÔÆ°:%ld²ó", (p_ptr->csp + 100-p_ptr->energy_need - 50)/100); break;
 326 #else
 327         case 13: sprintf(p, " %ld acts.", (p_ptr->csp + 100-p_ptr->energy_need - 50)/100); break;
 328 #endif
 329         }
 330       break;
 331     case MIND_KI:
 332       {
 333         int boost = p_ptr->magic_num1[0];
 334
 335         if (heavy_armor()) boost /= 2;
 336
 337         switch (power)
 338           {
 339           case 0:  sprintf(p, " %s%dd4", s_dam, 3 + ((plev - 1) / 5) + boost / 12); break;
 340           case 1:  break;
 341           case 2:  sprintf(p, " %s%d+d30", s_dur, 30 + boost / 5); break;
 342           case 3:  sprintf(p, " %s%dd5", s_dam, 5 + ((plev - 1) / 5) + boost / 10); break;
 343           case 4:  sprintf(p, " %s%d+d20", s_dur, 20 + boost / 5); break;
 344           case 5:  break;
 345           case 6:  sprintf(p, " %s%d+d%d", s_dur, 15 + boost / 7, plev / 2); break;
 346           case 7:  sprintf(p, " %s%dd8", s_dam, 8 + ((plev - 5) / 5) + boost / 12); break;
 347           case 8:  sprintf(p, " %s10d6+%d", s_dam, plev * 3 / 2 + boost * 3 / 5); break;
 348           case 9:  break;
 349 #ifdef JP
 350           case 10: sprintf(p, " ºÇÂç%dÉ¤", 1+boost/100); break;
 351 #else
 352           case 10: sprintf(p, " max %d", 1+boost/100); break;
 353 #endif
 354           case 11: sprintf(p, " %s%d", s_dam, 100 + plev + boost); break;
 355           case 12: sprintf(p, " %s%dd15", s_dam, 10 + plev / 2 + boost * 3 / 10); break;
 356 #ifdef JP
 357           case 13: sprintf(p, " ¹ÔÆ°:%d+d16²ó", 16+boost/20); break;
 358 #else
 359           case 13: sprintf(p, " %d+d16 acts", 16+boost/20); break;
 360 #endif
 361           }
 362         break;
 363       case MIND_MIRROR_MASTER:
 364         {
 365           switch (power)
 366             {
 367             case 0:  break;
 368             case 1:  break;
 369             case 2:  sprintf(p, " %s%dd4", s_dam,  3 + ((plev - 1) / 5) ); break;
 370             case 3:  sprintf(p, " %s10", s_range); break;
 371             case 4:  break;
 372             case 5:  sprintf(p, " %s%d", s_range, plev *5); break;
 373             case 6:  sprintf(p, " %s20+d20", s_dur);  break;
 374             case 7:  break;
 375             case 8:  sprintf(p, " %s%dd8", s_dam, 8+((plev -5)/4) ); break;
 376             case 9:  break;
 377             case 10: sprintf(p, " %s%dd8", s_dam, 11+(plev-5)/4 ); break;
 378             case 11: break;
 379             case 12: sprintf(p, " %s20+d20", s_dur);  break;
 380             case 13: sprintf(p, " %s150+d%d", s_dam, plev*2 ); break;
 381             case 14: break;
 382             case 15: break;
 383             case 16: sprintf(p, " %s%d", s_range, plev/2 +10); break;
 384             case 17: break;
 385             case 18: sprintf(p, " %s6+d6", s_dur);  break;
 386             case 19: sprintf(p, " %s%d", s_dam, plev*11+5 ); break;
 387             case 20: sprintf(p, " %s4+d4", s_dur);  break;
 388             }
 389           break;
 390         }
 391       case MIND_NINJUTSU:
 392         {
 393           switch (power)
 394             {
 395             case 0:  break;
 396             case 1:  break;
 397             case 2:  sprintf(p, " %s10", s_range); break;
 398             case 3:  break;
 399             case 4:  sprintf(p, " %s%d", s_range , plev *5); break;
 400             case 5:  sprintf(p, " %s30", s_range); break;
 401             case 6:  break;
 402             case 7:  break;
 403             case 8:  sprintf(p, " %s20+d20", s_dur);  break;
 404             case 9:  sprintf(p, " %s%d", s_dam, (50+plev)/2 ); break;
 405             case 10: break;
 406             case 11: break;
 407             case 12: break;
 408             case 13: break;
 409             case 14: break;
 410             case 15: break;
 411             case 16: sprintf(p, " %s%d+d%d", s_dur, plev/2, plev/2);  break;
 412             case 17: sprintf(p, " %s%d*3", s_dam, (75+plev*2/3)/2 ); break;
 413             case 18: sprintf(p, " %s%dd10", s_dam, 6+plev/8 ); break;
 414             case 19: sprintf(p, " %s6+d6", s_dur);  break;
 415             }
 416           break;
 417         }
 418       }
 419     }
 420 }
 421
 422   /*
 423  * Allow user to choose a mindcrafter power.
 424  *
 425  * If a valid spell is chosen, saves it in '*sn' and returns TRUE
 426  * If the user hits escape, returns FALSE, and set '*sn' to -1
 427  * If there are no legal choices, returns FALSE, and sets '*sn' to -2
 428  *
 429  * The "prompt" should be "cast", "recite", or "study"
 430  * The "known" should be TRUE for cast/pray, FALSE for study
 431  *
 432  * nb: This function has a (trivial) display bug which will be obvious
 433  * when you run it. It's probably easy to fix but I haven't tried,
 434  * sorry.
 435  */
 436   static int get_mind_power(int *sn, bool only_browse)
 437     {
 438       int             i;
 439       int             num = 0;
 440       int             y = 1;
 441       int             x = 10;
 442       int             minfail = 0;
 443       int             plev = p_ptr->lev;
 444       int             chance = 0;
 445       int             ask = TRUE;
 446       char            choice;
 447       char            out_val[160];
 448       char            comment[80];
 449       cptr            p;
 450
 451       mind_type       spell;
 452       mind_power      *mind_ptr;
 453       bool            flag, redraw;
 454       int             use_mind;
 455       int menu_line = (use_menu ? 1 : 0);
 456
 457       switch(p_ptr->pclass)
 458         {
 459         case CLASS_MINDCRAFTER:
 460           {
 461             use_mind = MIND_MINDCRAFTER;
 462 #ifdef JP
 463             p = "Ä¶Ç½ÎÏ";
 464 #else
 465             p = "mindcraft";
 466 #endif
 467             break;
 468           }
 469         case CLASS_FORCETRAINER:
 470           {
 471             use_mind = MIND_KI;
 472 #ifdef JP
 473             p = "Îýµ¤½Ñ";
 474 #else
 475             p = "Force";
 476 #endif
 477             break;
 478           }
 479         case CLASS_BERSERKER:
 480           {
 481             use_mind = MIND_BERSERKER;
 482 #ifdef JP
 483             p = "µ»";
 484 #else
 485             p = "brutal power";
 486 #endif
 487             break;
 488           }
 489         case CLASS_MIRROR_MASTER:
 490           {
 491             use_mind = MIND_MIRROR_MASTER;
 492 #ifdef JP
 493             p = "¶ÀËâË¡";
 494 #else
 495             p = "magic";
 496 #endif
 497             break;
 498           }
 499         case CLASS_NINJA:
 500           {
 501             use_mind = MIND_NINJUTSU;
 502 #ifdef JP
 503             p = "Ç¦½Ñ";
 504 #else
 505             p = "ninjutsu";
 506 #endif
 507             break;
 508           }
 509         default:
 510           {
 511             use_mind = 0;
 512 #ifdef JP
 513             p = "Ä¶Ç½ÎÏ";
 514 #else
 515             p = "mindcraft";
 516 #endif
 517             break;
 518           }
 519         }
 520       mind_ptr = &mind_powers[use_mind];
 521
 522         /* Assume cancelled */
 523       *sn = (-1);
 524
 525 #ifdef ALLOW_REPEAT /* TNB */
 526
 527         /* Get the spell, if available */
 528         if (repeat_pull(sn))
 529         {
 530                 /* Hack -- If requested INVEN_FORCE(1111), pull again */
 531                 if (*sn == INVEN_FORCE) repeat_pull(sn);
 532
 533                 /* Verify the spell */
 534                 if (mind_ptr->info[*sn].min_lev <= plev)
 535                 {
 536                         /* Success */
 537                         return (TRUE);
 538                 }
 539         }
 540
 541 #endif /* ALLOW_REPEAT -- TNB */
 542
 543       /* Nothing chosen yet */
 544       flag = FALSE;
 545
 546       /* No redraw yet */
 547       redraw = FALSE;
 548
 549       for (i = 0; i < MAX_MIND_POWERS; i++)
 550         {
 551           if (mind_ptr->info[i].min_lev <= plev)
 552             {
 553               num++;
 554             }
 555         }
 556
 557       /* Build a prompt (accept all spells) */
 558       if (only_browse)
 559         {
 560 #ifdef JP
 561           (void) strnfmt(out_val, 78, "(%^s %c-%c, '*'¤Ç°ìÍ÷, ESC) ¤É¤Î%s¤Ë¤Ä¤¤¤ÆÃÎ¤ê¤Þ¤¹¤«¡©",
 562 #else
 563           (void) strnfmt(out_val, 78, "(%^ss %c-%c, *=List, ESC=exit) Use which %s? ",
 564 #endif
 565                                        p, I2A(0), I2A(num - 1), p);
 566           }
 567         else
 568           {
 569 #ifdef JP
 570 (void) strnfmt(out_val, 78, "(%^s %c-%c, '*'¤Ç°ìÍ÷, ESC) ¤É¤Î%s¤ò»È¤¤¤Þ¤¹¤«¡©",
 571 #else
 572                 (void)strnfmt(out_val, 78, "(%^ss %c-%c, *=List, ESC=exit) Use which %s? ",
 573 #endif
 574                 p, I2A(0), I2A(num - 1), p);
 575         }
 576
 577         if (use_menu && !only_browse) screen_save();
 578         /* Get a spell from the user */
 579
 580         choice= (always_show_list || use_menu) ? ESCAPE:1 ;
 581         while (!flag)
 582         {
 583                 if(choice==ESCAPE) choice = ' ';
 584                 else if( !get_com(out_val, &choice, TRUE) )break;
 585
 586                 if (use_menu && choice != ' ')
 587                 {
 588                         switch(choice)
 589                         {
 590                                 case '0':
 591                                 {
 592                                         if (!only_browse) screen_load();
 593                                         return (FALSE);
 594                                 }
 595
 596                                 case '8':
 597                                 case 'k':
 598                                 case 'K':
 599                                 {
 600                                         menu_line += (num - 1);
 601                                         break;
 602                                 }
 603
 604                                 case '2':
 605                                 case 'j':
 606                                 case 'J':
 607                                 {
 608                                         menu_line++;
 609                                         break;
 610                                 }
 611
 612                                 case 'x':
 613                                 case 'X':
 614                                 case '\r':
 615                                 case '\n':
 616                                 {
 617                                         i = menu_line - 1;
 618                                         ask = FALSE;
 619                                         break;
 620                                 }
 621                         }
 622                         if (menu_line > num) menu_line -= num;
 623                 }
 624                 /* Request redraw */
 625                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
 626                 {
 627                         /* Show the list */
 628                         if (!redraw || use_menu)
 629                         {
 630                                 char psi_desc[80];
 631                                 bool has_weapon[2];
 632
 633                                 /* Show list */
 634                                 redraw = TRUE;
 635
 636                                 /* Save the screen */
 637                                 if (!only_browse && !use_menu) screen_save();
 638
 639                                 /* Display a list of spells */
 640                                 prt("", y, x);
 641 #ifdef JP
 642 put_str("Ì¾Á°", y, x + 5);
 643 #else
 644                                 put_str("Name", y, x + 5);
 645 #endif
 646
 647 #ifdef JP
 648 put_str(format("Lv   %s   ¼ºÎ¨ ¸ú²Ì", ((use_mind == MIND_BERSERKER) || (use_mind == MIND_NINJUTSU)) ? "HP" : "MP"), y, x + 35);
 649 #else
 650 put_str(format("Lv   %s   Fail Info", ((use_mind == MIND_BERSERKER) || (use_mind == MIND_NINJUTSU)) ? "HP" : "MP"), y, x + 35);
 651 #endif
 652                                 has_weapon[0] = buki_motteruka(INVEN_RARM);
 653                                 has_weapon[1] = buki_motteruka(INVEN_LARM);
 654
 655                                 /* Dump the spells */
 656                                 for (i = 0; i < MAX_MIND_POWERS; i++)
 657                                 {
 658                                         int mana_cost;
 659
 660                                         /* Access the spell */
 661                                         spell = mind_ptr->info[i];
 662
 663                                         if (spell.min_lev > plev)   break;
 664
 665                                         chance = spell.fail;
 666
 667                                         mana_cost = spell.mana_cost;
 668                                         if (chance)
 669                                         {
 670
 671                                                 /* Reduce failure rate by "effective" level adjustment */
 672                                                 chance -= 3 * (plev - spell.min_lev);
 673
 674                                                 /* Reduce failure rate by INT/WIS adjustment */
 675                                                 chance -= 3 * (adj_mag_stat[p_ptr->stat_ind[mp_ptr->spell_stat]] - 1);
 676
 677                                                 if (use_mind == MIND_KI)
 678                                                 {
 679                                                         if (heavy_armor()) chance += 20;
 680                                                         if (p_ptr->icky_wield[0]) chance += 20;
 681                                                         else if (has_weapon[0]) chance += 10;
 682                                                         if (p_ptr->icky_wield[1]) chance += 20;
 683                                                         else if (has_weapon[1]) chance += 10;
 684                                                         if (i == 5)
 685                                                         {
 686                                                                 int j;
 687                                                                 for (j = 0; j < p_ptr->magic_num1[0] / 50; j++)
 688                                                                         mana_cost += (j+1) * 3 / 2;
 689                                                         }
 690                                                 }
 691
 692                                                 /* Not enough mana to cast */
 693                                                 if ((use_mind != MIND_BERSERKER) && (use_mind != MIND_NINJUTSU) && (mana_cost > p_ptr->csp))
 694                                                 {
 695                                                         chance += 5 * (mana_cost - p_ptr->csp);
 696                                                 }
 697
 698                                                 chance += p_ptr->to_m_chance;
 699
 700                                                 /* Extract the minimum failure rate */
 701                                                 minfail = adj_mag_fail[p_ptr->stat_ind[mp_ptr->spell_stat]];
 702
 703                                                 /* Minimum failure rate */
 704                                                 if (chance < minfail) chance = minfail;
 705
 706                                                 /* Stunning makes spells harder */
 707                                                 if (p_ptr->stun > 50) chance += 25;
 708                                                 else if (p_ptr->stun) chance += 15;
 709
 710                                                 if (use_mind == MIND_KI)
 711                                                 {
 712                                                         if (heavy_armor()) chance += 5;
 713                                                         if (p_ptr->icky_wield[0]) chance += 5;
 714                                                         if (p_ptr->icky_wield[1]) chance += 5;
 715                                                 }
 716                                                 /* Always a 5 percent chance of working */
 717                                                 if (chance > 95) chance = 95;
 718                                         }
 719
 720                                         /* Get info */
 721                                         mindcraft_info(comment, use_mind, i);
 722
 723                                         if (use_menu)
 724                                         {
 725 #ifdef JP
 726                                                 if (i == (menu_line-1)) strcpy(psi_desc, "  ¡Õ ");
 727 #else
 728                                                 if (i == (menu_line-1)) strcpy(psi_desc, "  >  ");
 729 #endif
 730                                                 else strcpy(psi_desc, "     ");
 731                                         }
 732                                         else
 733                                                 sprintf(psi_desc, "  %c) ",I2A(i));
 734                                         /* Dump the spell --(-- */
 735                                         strcat(psi_desc,
 736                                                format("%-30s%2d %4d%s %3d%%%s",
 737                                                       spell.name, spell.min_lev, mana_cost,
 738 #ifdef JP
 739                                                       (((use_mind == MIND_MINDCRAFTER) && (i == 13)) ? "¡Á" : "  "),
 740 #else
 741                                                       (((use_mind == MIND_MINDCRAFTER) && (i == 13)) ? "~ " : "  "),
 742 #endif
 743                                                       chance, comment));
 744                                         prt(psi_desc, y + i + 1, x);
 745                                 }
 746
 747                                 /* Clear the bottom line */
 748                                 prt("", y + i + 1, x);
 749                         }
 750
 751                         /* Hide the list */
 752                         else if (!only_browse)
 753                         {
 754                                 /* Hide list */
 755                                 redraw = FALSE;
 756
 757                                 /* Restore the screen */
 758                                 screen_load();
 759                         }
 760
 761                         /* Redo asking */
 762                         continue;
 763                 }
 764
 765                 if (!use_menu)
 766                 {
 767                         /* Note verify */
 768                         ask = isupper(choice);
 769
 770                         /* Lowercase */
 771                         if (ask) choice = tolower(choice);
 772
 773                         /* Extract request */
 774                         i = (islower(choice) ? A2I(choice) : -1);
 775                 }
 776
 777                 /* Totally Illegal */
 778                 if ((i < 0) || (i >= num))
 779                 {
 780                         bell();
 781                         continue;
 782                 }
 783
 784                 /* Save the spell index */
 785                 spell = mind_ptr->info[i];
 786
 787                 /* Verify it */
 788                 if (ask)
 789                 {
 790                         char tmp_val[160];
 791
 792                         /* Prompt */
 793 #ifdef JP
 794 (void) strnfmt(tmp_val, 78, "%s¤ò»È¤¤¤Þ¤¹¤«¡©", spell.name);
 795 #else
 796                         (void)strnfmt(tmp_val, 78, "Use %s? ", spell.name);
 797 #endif
 798
 799
 800                         /* Belay that order */
 801                         if (!get_check(tmp_val)) continue;
 802                 }
 803
 804                 /* Stop the loop */
 805                 flag = TRUE;
 806         }
 807
 808         /* Restore the screen */
 809         if (redraw && !only_browse) screen_load();
 810
 811         /* Show choices */
 812         p_ptr->window |= (PW_SPELL);
 813
 814         /* Window stuff */
 815         window_stuff();
 816
 817         /* Abort if needed */
 818         if (!flag) return (FALSE);
 819
 820         /* Save the choice */
 821         (*sn) = i;
 822
 823 #ifdef ALLOW_REPEAT /* TNB */
 824
 825         repeat_push(*sn);
 826
 827 #endif /* ALLOW_REPEAT -- TNB */
 828
 829         /* Success */
 830         return (TRUE);
 831 }
 832
 833
 834 /*
 835  * do_cmd_cast calls this function if the player's class
 836  * is 'mindcrafter'.
 837  */
 838 static bool cast_mindcrafter_spell(int spell)
 839 {
 840         int             b = 0;
 841         int             dir;
 842         int             plev = p_ptr->lev;
 843
 844         /* spell code */
 845         switch (spell)
 846         {
 847         case 0:   /* Precog */
 848                 if (plev > 44)
 849                 {
 850                         chg_virtue(V_KNOWLEDGE, 1);
 851                         chg_virtue(V_ENLIGHTEN, 1);
 852                         wiz_lite(FALSE);
 853                 }
 854                 else if (plev > 19)
 855                         map_area(DETECT_RAD_MAP);
 856
 857                 if (plev < 30)
 858                 {
 859                         b = detect_monsters_normal(DETECT_RAD_DEFAULT);
 860                         if (plev > 14) b |= detect_monsters_invis(DETECT_RAD_DEFAULT);
 861                         if (plev > 4)  {
 862                                 b |= detect_traps(DETECT_RAD_DEFAULT, TRUE);
 863                                 b |= detect_doors(DETECT_RAD_DEFAULT);
 864                         }
 865                 }
 866                 else
 867                 {
 868                         b = detect_all(DETECT_RAD_DEFAULT);
 869                 }
 870
 871                 if ((plev > 24) && (plev < 40))
 872                         set_tim_esp(plev, FALSE);
 873
 874 #ifdef JP
 875 if (!b) msg_print("°ÂÁ´¤Êµ¤¤¬¤¹¤ë¡£");
 876 #else
 877                 if (!b) msg_print("You feel safe.");
 878 #endif
 879
 880                 break;
 881         case 1:
 882                 /* Mindblast */
 883                 if (!get_aim_dir(&dir)) return FALSE;
 884
 885                 if (randint1(100) < plev * 2)
 886                         fire_beam(GF_PSI, dir, damroll(3 + ((plev - 1) / 4), (3 + plev / 15)));
 887                 else
 888                         fire_ball(GF_PSI, dir, damroll(3 + ((plev - 1) / 4), (3 + plev / 15)), 0);
 889                 break;
 890         case 2:
 891                 /* Minor displace */
 892                 teleport_player(10, FALSE);
 893                 break;
 894         case 3:
 895                 /* Major displace */
 896                 teleport_player(plev * 5, FALSE);
 897                 break;
 898         case 4:
 899                 /* Domination */
 900                 if (plev < 30)
 901                 {
 902                         if (!get_aim_dir(&dir)) return FALSE;
 903
 904                         fire_ball(GF_DOMINATION, dir, plev, 0);
 905                 }
 906                 else
 907                 {
 908                         charm_monsters(plev * 2);
 909                 }
 910                 break;
 911         case 5:
 912                 /* Fist of Force  ---  not 'true' TK  */
 913                 if (!get_aim_dir(&dir)) return FALSE;
 914
 915                 fire_ball(GF_TELEKINESIS, dir, damroll(8 + ((plev - 5) / 4), 8),
 916                         (plev > 20 ? (plev - 20) / 8 + 1 : 0));
 917                 break;
 918         case 6:
 919                 /* Character Armour */
 920                 set_shield(plev, FALSE);
 921                 if (plev > 14) set_oppose_acid(plev, FALSE);
 922                 if (plev > 19) set_oppose_fire(plev, FALSE);
 923                 if (plev > 24) set_oppose_cold(plev, FALSE);
 924                 if (plev > 29) set_oppose_elec(plev, FALSE);
 925                 if (plev > 34) set_oppose_pois(plev, FALSE);
 926                 break;
 927         case 7:
 928                 /* Psychometry */
 929                 if (plev < 25)
 930                         return psychometry();
 931                 else
 932                         return ident_spell(FALSE);
 933         case 8:
 934                 /* Mindwave */
 935 #ifdef JP
 936 msg_print("Àº¿À¤òÇ±¤¸¶Ê¤²¤ëÇÈÆ°¤òÈ¯À¸¤µ¤»¤¿¡ª");
 937 #else
 938                 msg_print("Mind-warping forces emanate from your brain!");
 939 #endif
 940
 941                 if (plev < 25)
 942                         project(0, 2 + plev / 10, py, px,
 943                         (plev * 3), GF_PSI, PROJECT_KILL, -1);
 944                 else
 945                         (void)mindblast_monsters(randint1(plev * ((plev - 5) / 10 + 1)));
 946                 break;
 947         case 9:
 948                 /* Adrenaline */
 949                 set_afraid(0);
 950                 set_stun(0);
 951
 952                 /*
 953                  * Only heal when Adrenalin Channeling is not active. We check
 954                  * that by checking if the player isn't fast and 'heroed' atm.
 955                  */
 956                 if (!IS_FAST() || !IS_HERO())
 957                 {
 958                         hp_player(plev);
 959                 }
 960
 961                 b = 10 + randint1((plev * 3) / 2);
 962                 set_hero(b, FALSE);
 963                 /* Haste */
 964                 (void)set_fast(b, FALSE);
 965                 break;
 966         case 10:
 967                 /* Telekinesis */
 968                 if (!get_aim_dir(&dir)) return FALSE;
 969
 970                 fetch(dir, plev * 15, FALSE);
 971
 972                 break;
 973         case 11:
 974                 /* Psychic Drain */
 975                 if (!get_aim_dir(&dir)) return FALSE;
 976
 977                 b = damroll(plev / 2, 6);
 978
 979                 /* This is always a radius-0 ball now */
 980                 if (fire_ball(GF_PSI_DRAIN, dir, b, 0))
 981                         p_ptr->energy_need += randint1(150);
 982                 break;
 983         case 12:
 984                 /* psycho-spear */
 985                 if (!get_aim_dir(&dir)) return FALSE;
 986
 987                 fire_beam(GF_PSY_SPEAR, dir, randint1(plev*3)+plev*3);
 988                 break;
 989         case 13:
 990         {
 991                 if (world_player)
 992                 {
 993 #ifdef JP
 994                         msg_print("´û¤Ë»þ¤Ï»ß¤Þ¤Ã¤Æ¤¤¤ë¡£");
 995 #else
 996                         msg_print("Time is already stopped.");
 997 #endif
 998                         return (FALSE);
 999                 }
1000                 world_player = TRUE;
1001 #ifdef JP
1002                 msg_print("¡Ö»þ¤è¡ª¡×");
1003 #else
1004                 msg_print("You yell 'Time!'");
1005 #endif
1006                 msg_print(NULL);
1007
1008                 /* Hack */
1009                 p_ptr->energy_need -= 1000 + (100 + p_ptr->csp - 50)*TURNS_PER_TICK/10;
1010
1011                 /* Redraw map */
1012                 p_ptr->redraw |= (PR_MAP);
1013
1014                 /* Update monsters */
1015                 p_ptr->update |= (PU_MONSTERS);
1016
1017                 /* Window stuff */
1018                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1019
1020                 handle_stuff();
1021                 break;
1022         }
1023         default:
1024 #ifdef JP
1025 msg_print("¤Ê¤Ë¡©");
1026 #else
1027                 msg_print("Zap?");
1028 #endif
1029
1030         }
1031
1032         return TRUE;
1033 }
1034
1035
1036 /*
1037  * do_cmd_cast calls this function if the player's class
1038  * is 'ForceTrainer'.
1039  */
1040 static bool cast_force_spell(int spell)
1041 {
1042         int             dir;
1043         int             plev = p_ptr->lev;
1044         int             boost = p_ptr->magic_num1[0];
1045
1046         if (heavy_armor()) boost /= 2;
1047
1048         /* spell code */
1049         switch (spell)
1050         {
1051         case 0:
1052                 if (!get_aim_dir(&dir)) return FALSE;
1053                 fire_ball(GF_MISSILE, dir, damroll(3 + ((plev - 1) / 5) + boost / 12, 4), 0);
1054                 break;
1055         case 1:
1056                 (void)lite_area(damroll(2, (plev / 2)), (plev / 10) + 1);
1057                 break;
1058         case 2:
1059                 set_tim_levitation(randint1(30) + 30 + boost / 5, FALSE);
1060                 break;
1061         case 3:
1062                 project_length = plev / 8 + 3;
1063                 if (!get_aim_dir(&dir)) return FALSE;
1064
1065                 fire_beam(GF_MISSILE, dir, damroll(5 + ((plev - 1) / 5) + boost / 10, 5));
1066                 break;
1067         case 4:
1068                 set_resist_magic(randint1(20) + 20 + boost / 5, FALSE);
1069                 break;
1070         case 5:
1071 #ifdef JP
1072                 msg_print("µ¤¤òÎý¤Ã¤¿¡£");
1073 #else
1074                 msg_print("You improved the Force.");
1075 #endif
1076                 p_ptr->magic_num1[0] += (70 + plev);
1077                 p_ptr->update |= (PU_BONUS);
1078                 if (randint1(p_ptr->magic_num1[0]) > (plev * 4 + 120))
1079                 {
1080 #ifdef JP
1081                         msg_print("µ¤¤¬Ë½Áö¤·¤¿¡ª");
1082 #else
1083                         msg_print("The Force exploded!");
1084 #endif
1085                         fire_ball(GF_MANA, 0, p_ptr->magic_num1[0] / 2, 10);
1086 #ifdef JP
1087                         take_hit(DAMAGE_LOSELIFE, p_ptr->magic_num1[0] / 2, "µ¤¤ÎË½Áö", -1);
1088 #else
1089                         take_hit(DAMAGE_LOSELIFE, p_ptr->magic_num1[0] / 2, "Explosion of the Force", -1);
1090 #endif
1091                 }
1092                 else return TRUE;
1093                 break;
1094         case 6:
1095                 set_tim_sh_touki(randint1(plev / 2) + 15 + boost / 7, FALSE);
1096                 break;
1097         case 7:
1098         {
1099                 int y, x, dam;
1100                 project_length = 1;
1101                 if (!get_aim_dir(&dir)) return FALSE;
1102
1103                 y = py + ddy[dir];
1104                 x = px + ddx[dir];
1105                 dam = damroll(8 + ((plev - 5) / 4) + boost / 12, 8);
1106                 fire_beam(GF_MISSILE, dir, dam);
1107                 if (cave[y][x].m_idx)
1108                 {
1109                         int i;
1110                         int ty = y, tx = x;
1111                         int oy = y, ox = x;
1112                         int m_idx = cave[y][x].m_idx;
1113                         monster_type *m_ptr = &m_list[m_idx];
1114                         monster_race *r_ptr = &r_info[m_ptr->r_idx];
1115                         char m_name[80];
1116
1117                         monster_desc(m_name, m_ptr, 0);
1118
1119                         if (randint1(r_ptr->level * 3 / 2) > randint0(dam / 2) + dam/2)
1120                         {
1121 #ifdef JP
1122                                 msg_format("%s¤ÏÈô¤Ð¤µ¤ì¤Ê¤«¤Ã¤¿¡£", m_name);
1123 #else
1124                                 msg_format("%^s was not blown away.", m_name);
1125 #endif
1126                         }
1127                         else
1128                         {
1129                                 for (i = 0; i < 5; i++)
1130                                 {
1131                                         y += ddy[dir];
1132                                         x += ddx[dir];
1133                                         if (cave_empty_bold(y, x))
1134                                         {
1135                                                 ty = y;
1136                                                 tx = x;
1137                                         }
1138                                         else break;
1139                                 }
1140                                 if ((ty != oy) || (tx != ox))
1141                                 {
1142 #ifdef JP
1143                                         msg_format("%s¤ò¿á¤Èô¤Ð¤·¤¿¡ª", m_name);
1144 #else
1145                                         msg_format("You blow %s away!", m_name);
1146 #endif
1147                                         cave[oy][ox].m_idx = 0;
1148                                         cave[ty][tx].m_idx = m_idx;
1149                                         m_ptr->fy = ty;
1150                                         m_ptr->fx = tx;
1151
1152                                         update_mon(m_idx, TRUE);
1153                                         lite_spot(oy, ox);
1154                                         lite_spot(ty, tx);
1155
1156                                         if (r_ptr->flags7 & (RF7_LITE_MASK | RF7_DARK_MASK))
1157                                                 p_ptr->update |= (PU_MON_LITE);
1158                                 }
1159                         }
1160                 }
1161                 break;
1162         }
1163         case 8:
1164                 if (!get_aim_dir(&dir)) return FALSE;
1165                 fire_ball(GF_MISSILE, dir, damroll(10, 6) + plev * 3 / 2 + boost * 3 / 5, (plev < 30) ? 2 : 3);
1166                 break;
1167         case 9:
1168         {
1169                 monster_type *m_ptr;
1170                 bool need_mproc_remove = FALSE;
1171                 char m_name[80];
1172
1173                 if (!target_set(TARGET_KILL)) return FALSE;
1174                 if (!cave[target_row][target_col].m_idx) break;
1175                 if (!player_has_los_bold(target_row, target_col)) break;
1176                 if (!projectable(py, px, target_row, target_col)) break;
1177                 m_ptr = &m_list[cave[target_row][target_col].m_idx];
1178                 monster_desc(m_name, m_ptr, 0);
1179                 if (m_ptr->invulner)
1180                 {
1181                         m_ptr->invulner = 0;
1182                         need_mproc_remove = TRUE;
1183                         if (m_ptr->ml)
1184                         {
1185 #ifdef JP
1186                                 msg_format("%s¤Ï¤â¤¦ÌµÅ¨¤Ç¤Ï¤Ê¤¤¡£", m_name);
1187 #else
1188                                 msg_format("%^s is no longer invulnerable.", m_name);
1189 #endif
1190                                 p_ptr->redraw |= (PR_HEALTH);
1191                                 if (p_ptr->riding == cave[target_row][target_col].m_idx) p_ptr->redraw |= (PR_UHEALTH);
1192                         }
1193                         m_ptr->energy_need += ENERGY_NEED();
1194                 }
1195                 if (m_ptr->fast)
1196                 {
1197                         m_ptr->fast = 0;
1198                         need_mproc_remove = TRUE;
1199 #ifdef JP
1200                         if (m_ptr->ml) msg_format("%s¤Ï¤â¤¦²ÃÂ®¤µ¤ì¤Æ¤¤¤Ê¤¤¡£", m_name);
1201 #else
1202                         if (m_ptr->ml) msg_format("%^s is no longer fast.", m_name);
1203 #endif
1204                 }
1205                 if (m_ptr->slow)
1206                 {
1207                         m_ptr->slow = 0;
1208                         need_mproc_remove = TRUE;
1209 #ifdef JP
1210                         if (m_ptr->ml) msg_format("%s¤Ï¤â¤¦¸ºÂ®¤µ¤ì¤Æ¤¤¤Ê¤¤¡£", m_name);
1211 #else
1212                         if (m_ptr->ml) msg_format("%^s is no longer slow.", m_name);
1213 #endif
1214                 }
1215
1216                 if (need_mproc_remove && !need_mproc(m_ptr)) mproc_remove(m_ptr->mproc_idx);
1217                 break;
1218         }
1219         case 10:
1220         {
1221                 int i;
1222                 bool success = FALSE;
1223
1224                 for (i = 0; i < 1 + boost/100; i++)
1225                         if (summon_specific(-1, py, px, plev, SUMMON_PHANTOM, PM_FORCE_PET))
1226                                 success = TRUE;
1227                 if (success)
1228                 {
1229 #ifdef JP
1230 msg_print("¸æÍÑ¤Ç¤´¤¶¤¤¤Þ¤¹¤¬¡¢¸æ¼ç¿ÍÍÍ¡©");
1231 #else
1232                         msg_print("'Your wish, master?'");
1233 #endif
1234                 }
1235                 else
1236                 {
1237 #ifdef JP
1238                         msg_print("²¿¤â¸½¤ì¤Ê¤«¤Ã¤¿¡£");
1239 #else
1240                         msg_print("Nothing happen.");
1241 #endif
1242                 }
1243                 break;
1244         }
1245         case 11:
1246                 fire_ball(GF_FIRE, 0, 200 + (2 * plev) + boost * 2, 10);
1247                 break;
1248         case 12:
1249                 if (!get_aim_dir(&dir)) return FALSE;
1250
1251                 fire_beam(GF_MANA, dir, damroll(10 + (plev / 2) + boost * 3 / 10, 15));
1252                 break;
1253         case 13:
1254                 set_lightspeed(randint1(16) + 16 + boost / 20, FALSE);
1255                 break;
1256         default:
1257 #ifdef JP
1258 msg_print("¤Ê¤Ë¡©");
1259 #else
1260                 msg_print("Zap?");
1261 #endif
1262
1263         }
1264         p_ptr->magic_num1[0] = 0;
1265         p_ptr->update |= (PU_BONUS);
1266
1267         return TRUE;
1268 }
1269
1270 /* by henkma */
1271 /* calculate mirrors */
1272 static int number_of_mirrors( void )
1273 {
1274   int x,y;
1275   int val=0;
1276   for( x=0 ; x < cur_wid ; x++ ){
1277     for( y=0 ; y < cur_hgt ; y++ ){
1278       if (is_mirror_grid(&cave[y][x])) val++;
1279     }
1280   }
1281   return val;
1282 }
1283
1284 static bool cast_mirror_spell(int spell)
1285 {
1286         int             dir;
1287         int             plev = p_ptr->lev;
1288         int             tmp;
1289         int             x,y;
1290
1291         /* spell code */
1292         switch (spell)
1293         {
1294         /* mirror of seeing */
1295         case 0:
1296           tmp = is_mirror_grid(&cave[py][px]) ? 4 : 0;
1297           if( plev + tmp > 4)detect_monsters_normal(DETECT_RAD_DEFAULT);
1298           if( plev + tmp > 18 )detect_monsters_invis(DETECT_RAD_DEFAULT);
1299           if( plev + tmp > 28 )set_tim_esp(plev,FALSE);
1300           if( plev + tmp > 38 )map_area(DETECT_RAD_MAP);
1301           if( tmp == 0 && plev < 5 ){
1302 #ifdef JP
1303             msg_print("¶À¤¬¤Ê¤¯¤Æ½¸Ãæ¤Ç¤¤Ê¤«¤Ã¤¿¡ª");
1304 #else
1305             msg_print("You need a mirror to concentrate!");
1306 #endif
1307           }
1308           break;
1309         /* drip of light */
1310         case 1:
1311           if( number_of_mirrors() < 4 + plev/10 ){
1312             place_mirror();
1313           }
1314           else {
1315 #ifdef JP
1316 msg_format("¤³¤ì°Ê¾å¶À¤ÏÀ©¸æ¤Ç¤¤Ê¤¤¡ª");
1317 #else
1318 msg_format("There are too many mirrors to control!");
1319 #endif
1320           }
1321           break;
1322         case 2:
1323           if (!get_aim_dir(&dir)) return FALSE;
1324           if ( plev > 9 && is_mirror_grid(&cave[py][px]) ) {
1325             fire_beam(GF_LITE, dir,damroll(3+((plev-1)/5),4));
1326           }
1327           else {
1328             fire_bolt(GF_LITE, dir,damroll(3+((plev-1)/5),4));
1329           }
1330           break;
1331         /* warped mirror */
1332         case 3:
1333           teleport_player(10, FALSE);
1334           break;
1335         /* mirror of light */
1336         case 4:
1337           (void)lite_area(damroll(2, (plev / 2)), (plev / 10) + 1);
1338           break;
1339         /* mirror of wandering */
1340         case 5:
1341           teleport_player(plev * 5, FALSE);
1342           break;
1343         /* robe of dust */
1344         case 6:
1345           set_dustrobe(20+randint1(20),FALSE);
1346           break;
1347         /* banishing mirror */
1348         case 7:
1349           if (!get_aim_dir(&dir)) return FALSE;
1350           (void)fire_beam(GF_AWAY_ALL, dir , plev);
1351           break;
1352         /* mirror clashing */
1353         case 8:
1354           if (!get_aim_dir(&dir)) return FALSE;
1355           fire_ball(GF_SHARDS, dir, damroll(8 + ((plev - 5) / 4), 8),
1356                     (plev > 20 ? (plev - 20) / 8 + 1 : 0));
1357           break;
1358         /* mirror sleeping */
1359         case 9:
1360           for(x=0;x<cur_wid;x++){
1361             for(y=0;y<cur_hgt;y++){
1362               if (is_mirror_grid(&cave[y][x])) {
1363                 project(0,2,y,x,plev,GF_OLD_SLEEP,(PROJECT_GRID|PROJECT_ITEM|PROJECT_KILL|PROJECT_JUMP|PROJECT_NO_HANGEKI),-1);
1364               }
1365             }
1366           }
1367           break;
1368         /* seeker ray */
1369         case 10:
1370           if (!get_aim_dir(&dir)) return FALSE;
1371           fire_beam(GF_SEEKER,dir, damroll(11+(plev-5)/4,8));
1372           break;
1373         /* seal of mirror */
1374         case 11:
1375           seal_of_mirror(plev*4+100);
1376           break;
1377         /* shield of water */
1378         case 12:
1379           tmp = 20+randint1(20);
1380           set_shield(tmp, FALSE);
1381           if( plev > 31 )set_tim_reflect(tmp, FALSE);
1382           if( plev > 39 )set_resist_magic(tmp,FALSE);
1383           break;
1384         /* super ray */
1385         case 13:
1386           if (!get_aim_dir(&dir)) return FALSE;
1387           fire_beam(GF_SUPER_RAY,dir, 150+randint1(2*plev));
1388           break;
1389         /* illusion light */
1390         case 14:
1391           tmp = is_mirror_grid(&cave[py][px]) ? 4 : 3;
1392           slow_monsters();
1393           stun_monsters(plev*tmp);
1394           confuse_monsters(plev*tmp);
1395           turn_monsters(plev*tmp);
1396           stun_monsters(plev*tmp);
1397           stasis_monsters(plev*tmp);
1398           break;
1399         /* mirror shift */
1400         case 15:
1401           if( !is_mirror_grid(&cave[py][px]) ){
1402 #ifdef JP
1403                 msg_print("¶À¤Î¹ñ¤Î¾ì½ê¤¬¤ï¤«¤é¤Ê¤¤¡ª");
1404 #else
1405                 msg_print("You cannot find out where is the world of mirror!");
1406 #endif
1407                 break;
1408           }
1409           alter_reality();
1410           break;
1411         /* mirror tunnel */
1412         case 16:
1413 #ifdef JP
1414           msg_print("¶À¤ÎÀ¤³¦¤òÄÌ¤êÈ´¤±¡Ä  ");
1415 #else
1416           msg_print("Go through the world of mirror...");
1417 #endif
1418           return mirror_tunnel();
1419
1420         /* mirror of recall */
1421         case 17:
1422                 return word_of_recall();
1423         /* multi-shadow */
1424         case 18:
1425           set_multishadow(6+randint1(6),FALSE);
1426           break;
1427         /* binding field */
1428         case 19:
1429 #ifdef JP
1430           if( !binding_field(plev*11+5) )msg_print("Å¬Åö¤Ê¶À¤òÁª¤Ù¤Ê¤«¤Ã¤¿¡ª");
1431 #else
1432           if( !binding_field(plev*11+5) )msg_print("You were not able to choose suitable mirrors!");
1433 #endif
1434           break;
1435         /* mirror of Ruffnor */
1436         case 20:
1437           (void)set_invuln(randint1(4)+4,FALSE);
1438           break;
1439         default:
1440 #ifdef JP
1441 msg_print("¤Ê¤Ë¡©");
1442 #else
1443                 msg_print("Zap?");
1444 #endif
1445
1446         }
1447         p_ptr->magic_num1[0] = 0;
1448
1449         return TRUE;
1450 }
1451
1452
1453 /*
1454  * do_cmd_cast calls this function if the player's class
1455  * is 'berserker'.
1456  */
1457 static bool cast_berserk_spell(int spell)
1458 {
1459         int y, x;
1460         int dir;
1461
1462         /* spell code */
1463         switch (spell)
1464         {
1465         case 0:
1466                 detect_monsters_mind(DETECT_RAD_DEFAULT);
1467                 break;
1468         case 1:
1469         {
1470                 if (p_ptr->riding)
1471                 {
1472 #ifdef JP
1473                         msg_print("¾èÇÏÃæ¤Ë¤ÏÌµÍý¤À¡£");
1474 #else
1475                         msg_print("You cannot do it when riding.");
1476 #endif
1477                         return FALSE;
1478                 }
1479
1480                 if (!get_rep_dir2(&dir)) return FALSE;
1481
1482                 if (dir == 5) return FALSE;
1483                 y = py + ddy[dir];
1484                 x = px + ddx[dir];
1485
1486                 if (!cave[y][x].m_idx)
1487                 {
1488 #ifdef JP
1489                         msg_print("¤½¤ÎÊý¸þ¤Ë¤Ï¥â¥ó¥¹¥¿¡¼¤Ï¤¤¤Þ¤»¤ó¡£");
1490 #else
1491                         msg_print("There is no monster.");
1492 #endif
1493                         return FALSE;
1494                 }
1495
1496                 py_attack(y, x, 0);
1497
1498                 if (!player_can_enter(cave[y][x].feat, 0) || is_trap(cave[y][x].feat))
1499                         break;
1500
1501                 y += ddy[dir];
1502                 x += ddx[dir];
1503
1504                 if (player_can_enter(cave[y][x].feat, 0) && !is_trap(cave[y][x].feat) && !cave[y][x].m_idx)
1505                 {
1506                         msg_print(NULL);
1507
1508                         /* Move the player */
1509                         (void)move_player_effect(y, x, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
1510                 }
1511                 break;
1512         }
1513         case 2:
1514         {
1515                 if (!get_rep_dir2(&dir)) return FALSE;
1516                 y = py + ddy[dir];
1517                 x = px + ddx[dir];
1518                 move_player(dir, easy_disarm, TRUE);
1519                 break;
1520         }
1521         case 3:
1522                 earthquake(py, px, 8+randint0(5));
1523                 break;
1524         case 4:
1525         {
1526                 cave_type       *c_ptr;
1527                 monster_type    *m_ptr;
1528
1529                 for (dir = 0; dir < 8; dir++)
1530                 {
1531                         y = py + ddy_ddd[dir];
1532                         x = px + ddx_ddd[dir];
1533                         c_ptr = &cave[y][x];
1534
1535                         /* Get the monster */
1536                         m_ptr = &m_list[c_ptr->m_idx];
1537
1538                         /* Hack -- attack monsters */
1539                         if (c_ptr->m_idx && (m_ptr->ml || cave_have_flag_bold(y, x, FF_PROJECT)))
1540                                 py_attack(y, x, 0);
1541                 }
1542                 break;
1543         }
1544         default:
1545 #ifdef JP
1546 msg_print("¤Ê¤Ë¡©");
1547 #else
1548                 msg_print("Zap?");
1549 #endif
1550
1551         }
1552         return TRUE;
1553 }
1554
1555
1556
1557 /*
1558  * do_cmd_cast calls this function if the player's class
1559  * is 'ninja'.
1560  */
1561 static bool cast_ninja_spell(int spell)
1562 {
1563         int x, y;
1564         int dir;
1565         int plev = p_ptr->lev;
1566
1567         /* spell code */
1568         switch (spell)
1569         {
1570         case 0:
1571                 (void)unlite_area(0, 3);
1572                 break;
1573         case 1:
1574                 if (plev > 44)
1575                 {
1576                         wiz_lite(TRUE);
1577                 }
1578                 detect_monsters_normal(DETECT_RAD_DEFAULT);
1579                 if (plev > 4)
1580                 {
1581                         detect_traps(DETECT_RAD_DEFAULT, TRUE);
1582                         detect_doors(DETECT_RAD_DEFAULT);
1583                         detect_stairs(DETECT_RAD_DEFAULT);
1584                 }
1585                 if (plev > 14)
1586                 {
1587                         detect_objects_normal(DETECT_RAD_DEFAULT);
1588                 }
1589                 break;
1590         case 2:
1591         {
1592                 teleport_player(10, FALSE);
1593                 break;
1594         }
1595         case 3:
1596         {
1597                 if (!(p_ptr->special_defense & NINJA_KAWARIMI))
1598                 {
1599 #ifdef JP
1600                         msg_print("Å¨¤Î¹¶·â¤ËÂÐ¤·¤ÆÉÒ´¶¤Ë¤Ê¤Ã¤¿¡£");
1601 #else
1602                         msg_print("You are now prepare to evade any attacks.");
1603 #endif
1604
1605                         p_ptr->special_defense |= NINJA_KAWARIMI;
1606                         p_ptr->redraw |= (PR_STATUS);
1607                 }
1608                 break;
1609         }
1610         case 4:
1611         {
1612                 teleport_player(p_ptr->lev * 5, FALSE);
1613                 break;
1614         }
1615         case 5:
1616         {
1617                 if (!get_rep_dir(&dir, FALSE)) return FALSE;
1618                 y = py + ddy[dir];
1619                 x = px + ddx[dir];
1620                 if (cave[y][x].m_idx)
1621                 {
1622                         py_attack(y, x, 0);
1623                         if (randint0(p_ptr->skill_dis) < 7)
1624 #ifdef JP
1625 msg_print("¤¦¤Þ¤¯Æ¨¤²¤é¤ì¤Ê¤«¤Ã¤¿¡£");
1626 #else
1627                                 msg_print("You failed to run away.");
1628 #endif
1629                         else
1630                         {
1631                                 teleport_player(30, FALSE);
1632                         }
1633                 }
1634                 else
1635                 {
1636 #ifdef JP
1637 msg_print("¤½¤ÎÊý¸þ¤Ë¤Ï¥â¥ó¥¹¥¿¡¼¤Ï¤¤¤Þ¤»¤ó¡£");
1638 #else
1639                         msg_print("You don't see any monster in this direction");
1640 #endif
1641
1642                         msg_print(NULL);
1643                 }
1644                 break;
1645         }
1646         case 6:
1647         {
1648                 if (!get_aim_dir(&dir)) return FALSE;
1649                 (void)stasis_monster(dir);
1650                 break;
1651         }
1652         case 7:
1653                 return ident_spell(FALSE);
1654         case 8:
1655                 set_tim_levitation(randint1(20) + 20, FALSE);
1656                 break;
1657         case 9:
1658                 fire_ball(GF_FIRE, 0, 50+plev, plev/10+2);
1659                 teleport_player(30, FALSE);
1660                 set_oppose_fire(plev, FALSE);
1661                 break;
1662         case 10:
1663                 return rush_attack(NULL);
1664         case 11:
1665         {
1666                 int i;
1667                 for (i = 0; i < 8; i++)
1668                 {
1669                         int slot;
1670
1671                         for (slot = 0; slot < INVEN_PACK; slot++)
1672                         {
1673                                 if (inventory[slot].tval == TV_SPIKE) break;
1674                         }
1675                         if (slot == INVEN_PACK)
1676                         {
1677 #ifdef JP
1678                                 if (!i) msg_print("¤¯¤µ¤Ó¤ò»ý¤Ã¤Æ¤¤¤Ê¤¤¡£");
1679                                 else msg_print("¤¯¤µ¤Ó¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
1680 #else
1681                                 if (!i) msg_print("You have no Iron Spikes.");
1682                                 else msg_print("You have no more Iron Spikes.");
1683 #endif
1684                                 return FALSE;
1685                         }
1686
1687                         /* Gives a multiplier of 2 at first, up to 3 at 40th */
1688                         do_cmd_throw_aux(1, FALSE, slot);
1689
1690                         energy_use = 100;
1691                 }
1692                 break;
1693         }
1694         case 12:
1695         {
1696                 monster_type *m_ptr;
1697                 int m_idx;
1698                 char m_name[80];
1699                 int i;
1700                 int path_n;
1701                 u16b path_g[512];
1702                 int ty,tx;
1703
1704                 if (!target_set(TARGET_KILL)) return FALSE;
1705                 m_idx = cave[target_row][target_col].m_idx;
1706                 if (!m_idx) break;
1707                 if (m_idx == p_ptr->riding) break;
1708                 if (!player_has_los_bold(target_row, target_col)) break;
1709                 if (!projectable(py, px, target_row, target_col)) break;
1710                 m_ptr = &m_list[m_idx];
1711                 monster_desc(m_name, m_ptr, 0);
1712 #ifdef JP
1713                 msg_format("%s¤ò°ú¤Ìá¤·¤¿¡£", m_name);
1714 #else
1715                 msg_format("You pull back %s.", m_name);
1716 #endif
1717
1718                 path_n = project_path(path_g, MAX_RANGE, target_row, target_col, py, px, 0);
1719                 ty = target_row, tx = target_col;
1720                 for (i = 1; i < path_n; i++)
1721                 {
1722                         int ny = GRID_Y(path_g[i]);
1723                         int nx = GRID_X(path_g[i]);
1724                         cave_type *c_ptr = &cave[ny][nx];
1725
1726                         if (in_bounds(ny, nx) && cave_empty_bold(ny, nx) &&
1727                             !(c_ptr->info & CAVE_OBJECT) &&
1728                                 !pattern_tile(ny, nx))
1729                         {
1730                                 ty = ny;
1731                                 tx = nx;
1732                         }
1733                 }
1734                 /* Update the old location */
1735                 cave[target_row][target_col].m_idx = 0;
1736
1737                 /* Update the new location */
1738                 cave[ty][tx].m_idx = m_idx;
1739
1740                 /* Move the monster */
1741                 m_ptr->fy = ty;
1742                 m_ptr->fx = tx;
1743
1744                 if (m_ptr->csleep)
1745                 {
1746                         /* Wake the monster up */
1747                         m_ptr->csleep = 0;
1748                         if (!need_mproc(m_ptr)) mproc_remove(m_ptr->mproc_idx);
1749                 }
1750
1751                 /* Update the monster (new location) */
1752                 update_mon(m_idx, TRUE);
1753
1754                 /* Redraw the old grid */
1755                 lite_spot(target_row, target_col);
1756
1757                 /* Redraw the new grid */
1758                 lite_spot(ty, tx);
1759
1760                 if (r_info[m_ptr->r_idx].flags7 & (RF7_LITE_MASK | RF7_DARK_MASK))
1761                         p_ptr->update |= (PU_MON_LITE);
1762
1763                 if (m_ptr->ml)
1764                 {
1765                         /* Auto-Recall if possible and visible */
1766                         monster_race_track(m_ptr->ap_r_idx);
1767
1768                         /* Track a new monster */
1769                         health_track(m_idx);
1770                 }
1771
1772                 break;
1773         }
1774         case 13:
1775                 if (!get_aim_dir(&dir)) return FALSE;
1776                 fire_ball(GF_OLD_CONF, dir, plev*3, 3);
1777                 break;
1778         case 14:
1779                 project_length = -1;
1780                 if (!get_aim_dir(&dir))
1781                 {
1782                         project_length = 0;
1783                         return FALSE;
1784                 }
1785                 project_length = 0;
1786
1787                 (void)teleport_swap(dir);
1788                 break;
1789         case 15:
1790                 explosive_rune();
1791                 break;
1792         case 16:
1793                 (void)set_kabenuke(randint1(plev/2) + plev/2, FALSE);
1794                 set_oppose_acid(plev, FALSE);
1795                 break;
1796         case 17:
1797                 fire_ball(GF_POIS, 0, 75+plev*2/3, plev/5+2);
1798                 fire_ball(GF_OLD_DRAIN, 0, 75+plev*2/3, plev/5+2);
1799                 fire_ball(GF_CONFUSION, 0, 75+plev*2/3, plev/5+2);
1800                 teleport_player(30, FALSE);
1801                 break;
1802         case 18:
1803         {
1804                 int k;
1805                 int num = damroll(3, 9);
1806
1807                 for (k = 0; k < num; k++)
1808                 {
1809                         int typ = one_in_(2) ? GF_FIRE : one_in_(3) ? GF_NETHER : GF_PLASMA;
1810                         int attempts = 1000;
1811
1812                         while (attempts--)
1813                         {
1814                                 scatter(&y, &x, py, px, 4, 0);
1815
1816                                 if (!player_bold(y, x)) break;
1817                         }
1818                         project(0, 0, y, x, damroll(6 + plev / 8, 10), typ,
1819                                 (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_KILL), -1);
1820                 }
1821                 break;
1822         }
1823         case 19:
1824                 set_multishadow(6+randint1(6), FALSE);
1825                 break;
1826         default:
1827 #ifdef JP
1828 msg_print("¤Ê¤Ë¡©");
1829 #else
1830                 msg_print("Zap?");
1831 #endif
1832
1833         }
1834         return TRUE;
1835 }
1836
1837
1838
1839 /*
1840  * do_cmd_cast calls this function if the player's class
1841  * is 'mindcrafter'.
1842  */
1843 void do_cmd_mind(void)
1844 {
1845         int             n = 0,  b = 0;
1846         int             chance;
1847         int             minfail = 0;
1848         int             plev = p_ptr->lev;
1849         int             old_csp = p_ptr->csp;
1850         mind_type       spell;
1851         bool            cast;
1852         int             use_mind, mana_cost;
1853 #ifdef JP
1854         cptr            p;
1855 #endif
1856         bool            on_mirror = FALSE;
1857
1858         /* not if confused */
1859         if (p_ptr->confused)
1860         {
1861 #ifdef JP
1862 msg_print("º®Íð¤·¤Æ¤¤¤Æ½¸Ãæ¤Ç¤¤Ê¤¤¡ª");
1863 #else
1864                 msg_print("You are too confused!");
1865 #endif
1866
1867                 return;
1868         }
1869
1870         /* get power */
1871         if (!get_mind_power(&n, FALSE)) return;
1872
1873 #ifdef JP
1874         switch(p_ptr->pclass)
1875         {
1876                 case CLASS_MINDCRAFTER: use_mind = MIND_MINDCRAFTER;p = "Àº¿À";break;
1877                 case CLASS_FORCETRAINER:          use_mind = MIND_KI;p = "µ¤";break;
1878                 case CLASS_BERSERKER:   use_mind = MIND_BERSERKER;p = "ÅÜ¤ê";break;
1879                 case CLASS_MIRROR_MASTER:   use_mind = MIND_MIRROR_MASTER;p = "¶ÀËâË¡";break;
1880                 case CLASS_NINJA:       use_mind = MIND_NINJUTSU;p = "Àº¿À";break;
1881                 default:                use_mind = 0;p = "Ä¶Ç½ÎÏ";break;
1882         }
1883 #else
1884         switch(p_ptr->pclass)
1885         {
1886                 case CLASS_MINDCRAFTER: use_mind = MIND_MINDCRAFTER;break;
1887                 case CLASS_FORCETRAINER:          use_mind = MIND_KI;break;
1888                 case CLASS_BERSERKER:   use_mind = MIND_BERSERKER;break;
1889                 case CLASS_MIRROR_MASTER:   use_mind = MIND_MIRROR_MASTER;break;
1890                 case CLASS_NINJA:       use_mind = MIND_NINJUTSU;break;
1891                 default:                use_mind = 0;break;
1892         }
1893 #endif
1894         spell = mind_powers[use_mind].info[n];
1895
1896         /* Spell failure chance */
1897         chance = spell.fail;
1898
1899         mana_cost = spell.mana_cost;
1900         if (use_mind == MIND_KI)
1901         {
1902                 if (heavy_armor()) chance += 20;
1903                 if (p_ptr->icky_wield[0]) chance += 20;
1904                 else if (buki_motteruka(INVEN_RARM)) chance += 10;
1905                 if (p_ptr->icky_wield[1]) chance += 20;
1906                 else if (buki_motteruka(INVEN_LARM)) chance += 10;
1907                 if (n == 5)
1908                 {
1909                         int j;
1910                         for (j = 0; j < p_ptr->magic_num1[0] / 50; j++)
1911                                 mana_cost += (j+1) * 3 / 2;
1912                 }
1913         }
1914
1915         /* Verify "dangerous" spells */
1916         if ((use_mind == MIND_BERSERKER) || (use_mind == MIND_NINJUTSU))
1917         {
1918                 if (mana_cost > p_ptr->chp)
1919                 {
1920 #ifdef JP
1921 msg_print("£È£Ð¤¬Â¤ê¤Þ¤»¤ó¡£");
1922 #else
1923                         msg_print("You do not have enough hp to use this power.");
1924 #endif
1925                         return;
1926                 }
1927         }
1928         else if (mana_cost > p_ptr->csp)
1929         {
1930                 /* Warning */
1931 #ifdef JP
1932 msg_print("£Í£Ð¤¬Â¤ê¤Þ¤»¤ó¡£");
1933 #else
1934                 msg_print("You do not have enough mana to use this power.");
1935 #endif
1936
1937
1938                 if (!over_exert) return;
1939
1940                 /* Verify */
1941 #ifdef JP
1942 if (!get_check("¤½¤ì¤Ç¤âÄ©Àï¤·¤Þ¤¹¤«? ")) return;
1943 #else
1944                 if (!get_check("Attempt it anyway? ")) return;
1945 #endif
1946
1947         }
1948
1949         if (chance)
1950         {
1951                 /* Reduce failure rate by "effective" level adjustment */
1952                 chance -= 3 * (plev - spell.min_lev);
1953
1954                 chance += p_ptr->to_m_chance;
1955
1956                 /* Reduce failure rate by INT/WIS adjustment */
1957                 chance -= 3 * (adj_mag_stat[p_ptr->stat_ind[mp_ptr->spell_stat]] - 1);
1958
1959                 /* Not enough mana to cast */
1960                 if ((mana_cost > p_ptr->csp) && (use_mind != MIND_BERSERKER) && (use_mind != MIND_NINJUTSU))
1961                 {
1962                         chance += 5 * (mana_cost - p_ptr->csp);
1963                 }
1964
1965                 /* Extract the minimum failure rate */
1966                 minfail = adj_mag_fail[p_ptr->stat_ind[mp_ptr->spell_stat]];
1967
1968                 /* Minimum failure rate */
1969                 if (chance < minfail) chance = minfail;
1970
1971                 /* Stunning makes spells harder */
1972                 if (p_ptr->stun > 50) chance += 25;
1973                 else if (p_ptr->stun) chance += 15;
1974
1975                 if (use_mind == MIND_KI)
1976                 {
1977                         if (heavy_armor()) chance += 5;
1978                         if (p_ptr->icky_wield[0]) chance += 5;
1979                         if (p_ptr->icky_wield[1]) chance += 5;
1980                 }
1981         }
1982
1983         /* Always a 5 percent chance of working */
1984         if (chance > 95) chance = 95;
1985
1986         /* Failed spell */
1987         if (randint0(100) < chance)
1988         {
1989                 if (flush_failure) flush();
1990 #ifdef JP
1991 msg_format("%s¤Î½¸Ãæ¤Ë¼ºÇÔ¤·¤¿¡ª",p);
1992 #else
1993                 msg_format("You failed to concentrate hard enough!");
1994 #endif
1995
1996                 sound(SOUND_FAIL);
1997
1998                 if ((use_mind != MIND_BERSERKER) && (use_mind != MIND_NINJUTSU))
1999                 {
2000                         if ((use_mind == MIND_KI) && (n != 5) && p_ptr->magic_num1[0])
2001                         {
2002 #ifdef JP
2003                                 msg_print("µ¤¤¬»¶¤Ã¤Æ¤·¤Þ¤Ã¤¿¡¥¡¥¡¥");
2004 #else
2005                                 msg_print("Your improved Force has gone away...");
2006 #endif
2007                                 p_ptr->magic_num1[0] = 0;
2008                         }
2009
2010                         if (randint1(100) < (chance / 2))
2011                         {
2012                                 /* Backfire */
2013                           b = randint1(100);
2014
2015                           if( use_mind == MIND_MINDCRAFTER ){
2016                                 if (b < 5)
2017                                 {
2018 #ifdef JP
2019 msg_print("¤Ê¤ó¤Æ¤³¤Ã¤¿¡ªÆ¬¤ÎÃæ¤¬¿¿¤ÃÇò¤Ë¤Ê¤Ã¤¿¡ª");
2020 #else
2021                                         msg_print("Oh, no! Your mind has gone blank!");
2022 #endif
2023
2024                                         lose_all_info();
2025                                 }
2026                                 else if (b < 15)
2027                                 {
2028 #ifdef JP
2029 msg_print("´ñÌ¯¤Ê¸÷·Ê¤¬ÌÜ¤ÎÁ°¤ÇÍÙ¤Ã¤Æ¤¤¤ë...");
2030 #else
2031                                         msg_print("Weird visions seem to dance before your eyes...");
2032 #endif
2033
2034                                         set_image(p_ptr->image + 5 + randint1(10));
2035                                 }
2036                                 else if (b < 45)
2037                                 {
2038 #ifdef JP
2039 msg_print("¤¢¤Ê¤¿¤ÎÆ¬¤Ïº®Íð¤·¤¿¡ª");
2040 #else
2041                                         msg_print("Your brain is addled!");
2042 #endif
2043
2044                                         set_confused(p_ptr->confused + randint1(8));
2045                                 }
2046                                 else if (b < 90)
2047                                 {
2048                                         set_stun(p_ptr->stun + randint1(8));
2049                                 }
2050                                 else
2051                                 {
2052                                         /* Mana storm */
2053 #ifdef JP
2054 msg_format("%s¤ÎÎÏ¤¬À©¸æ¤Ç¤¤Ê¤¤ÈÅÎ®¤È¤Ê¤Ã¤Æ²òÊü¤µ¤ì¤¿¡ª", p);
2055 #else
2056                                         msg_print("Your mind unleashes its power in an uncontrollable storm!");
2057 #endif
2058
2059                                         project(1, 2 + plev / 10, py, px, plev * 2,
2060                                                 GF_MANA, PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM, -1);
2061                                         p_ptr->csp = MAX(0, p_ptr->csp - plev * MAX(1, plev / 10));
2062                                 }
2063                           }
2064                           if( use_mind == MIND_MIRROR_MASTER ){
2065                                 if (b < 51)
2066                                 {
2067                                   /* Nothing has happen */
2068                                 }
2069                                 else if (b < 81)
2070                                 {
2071 #ifdef JP
2072 msg_print("¶À¤ÎÀ¤³¦¤Î´³¾Ä¤ò¼õ¤±¤¿¡ª");
2073 #else
2074                                         msg_print("Weird visions seem to dance before your eyes...");
2075 #endif
2076                                         teleport_player(10, TRUE);
2077                                 }
2078                                 else if (b < 96)
2079                                 {
2080 #ifdef JP
2081 msg_print("¤Þ¤ï¤ê¤Î¤â¤Î¤¬¥¥é¥¥éµ±¤¤¤Æ¤¤¤ë¡ª");
2082 #else
2083                                         msg_print("Your brain is addled!");
2084 #endif
2085
2086                                         set_image(p_ptr->image + 5 + randint1(10));
2087                                 }
2088                                 else
2089                                 {
2090                                         /* Mana storm */
2091 #ifdef JP
2092 msg_format("%s¤ÎÎÏ¤¬À©¸æ¤Ç¤¤Ê¤¤ÈÅÎ®¤È¤Ê¤Ã¤Æ²òÊü¤µ¤ì¤¿¡ª", p);
2093 #else
2094                                         msg_print("Your mind unleashes its power in an uncontrollable storm!");
2095 #endif
2096
2097                                         project(1, 2 + plev / 10, py, px, plev * 2,
2098                                                 GF_MANA, PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM, -1);
2099                                         p_ptr->csp = MAX(0, p_ptr->csp - plev * MAX(1, plev / 10));
2100                                 }
2101                           }
2102                         }
2103                 }
2104         }
2105         else
2106         {
2107                 sound(SOUND_ZAP);
2108
2109                 switch(use_mind)
2110                 {
2111                 case MIND_MINDCRAFTER:
2112                         /* Cast the spell */
2113                         cast = cast_mindcrafter_spell(n);
2114                         break;
2115                 case MIND_KI:
2116                         /* Cast the spell */
2117                         cast = cast_force_spell(n);
2118                         break;
2119                 case MIND_BERSERKER:
2120                         /* Cast the spell */
2121                         cast = cast_berserk_spell(n);
2122                         break;
2123                 case MIND_MIRROR_MASTER:
2124                         /* Cast the spell */
2125                         if( is_mirror_grid(&cave[py][px]) )on_mirror = TRUE;
2126                         cast = cast_mirror_spell(n);
2127                         break;
2128                 case MIND_NINJUTSU:
2129                         /* Cast the spell */
2130                         cast = cast_ninja_spell(n);
2131                         break;
2132                 default:
2133 #ifdef JP
2134                         msg_format("Ææ¤ÎÇ½ÎÏ:%d, %d",use_mind, n);
2135 #else
2136                         msg_format("Mystery power:%d, %d",use_mind, n);
2137 #endif
2138                         return;
2139                 }
2140
2141                 if (!cast) return;
2142         }
2143
2144
2145         /* Take a turn */
2146         energy_use = 100;
2147         /* teleport from mirror costs small energy */
2148         if( on_mirror && p_ptr->pclass == CLASS_MIRROR_MASTER )
2149         {
2150           if( n==3 || n==5 || n==7 || n==16 )energy_use = 50;
2151         }
2152
2153         if ((use_mind == MIND_BERSERKER) || (use_mind == MIND_NINJUTSU))
2154         {
2155 #ifdef JP
2156                 take_hit(DAMAGE_USELIFE, mana_cost, "²áÅÙ¤Î½¸Ãæ", -1);
2157 #else
2158                 take_hit(DAMAGE_USELIFE, mana_cost, "concentrating too hard", -1);
2159 #endif
2160                 /* Redraw hp */
2161                 p_ptr->redraw |= (PR_HP);
2162         }
2163
2164         /* Sufficient mana */
2165         else if (mana_cost <= old_csp)
2166         {
2167                 /* Use some mana */
2168                 p_ptr->csp -= mana_cost;
2169
2170                 /* Limit */
2171                 if (p_ptr->csp < 0) p_ptr->csp = 0;
2172
2173                 if ((use_mind == MIND_MINDCRAFTER) && (n == 13))
2174                 {
2175                         /* No mana left */
2176                         p_ptr->csp = 0;
2177                         p_ptr->csp_frac = 0;
2178                 }
2179         }
2180
2181         /* Over-exert the player */
2182         else
2183         {
2184                 int oops = mana_cost - old_csp;
2185
2186                 /* No mana left */
2187                 if ((p_ptr->csp - mana_cost) < 0) p_ptr->csp_frac = 0;
2188                 p_ptr->csp = MAX(0, p_ptr->csp - mana_cost);
2189
2190                 /* Message */
2191 #ifdef JP
2192 msg_format("%s¤ò½¸Ãæ¤·¤¹¤®¤Æµ¤¤ò¼º¤Ã¤Æ¤·¤Þ¤Ã¤¿¡ª",p);
2193 #else
2194                 msg_print("You faint from the effort!");
2195 #endif
2196
2197
2198                 /* Hack -- Bypass free action */
2199                 (void)set_paralyzed(p_ptr->paralyzed + randint1(5 * oops + 1));
2200
2201                 /* Damage WIS (possibly permanently) */
2202                 if (randint0(100) < 50)
2203                 {
2204                         bool perm = (randint0(100) < 25);
2205
2206                         /* Message */
2207 #ifdef JP
2208 msg_print("¼«Ê¬¤ÎÀº¿À¤ò¹¶·â¤·¤Æ¤·¤Þ¤Ã¤¿¡ª");
2209 #else
2210                         msg_print("You have damaged your mind!");
2211 #endif
2212
2213
2214                         /* Reduce constitution */
2215                         (void)dec_stat(A_WIS, 15 + randint1(10), perm);
2216                 }
2217         }
2218
2219         /* Redraw mana */
2220         p_ptr->redraw |= (PR_MANA);
2221
2222         /* Window stuff */
2223         p_ptr->window |= (PW_PLAYER);
2224         p_ptr->window |= (PW_SPELL);
2225 }
2226
2227
2228 /*
2229  * do_cmd_cast calls this function if the player's class
2230  * is 'mindcrafter'.
2231  */
2232 void do_cmd_mind_browse(void)
2233 {
2234         int n = 0;
2235         int j, line;
2236         char temp[62*5];
2237         int use_mind = 0;
2238
2239         if (p_ptr->pclass == CLASS_MINDCRAFTER) use_mind = MIND_MINDCRAFTER;
2240         else if (p_ptr->pclass == CLASS_FORCETRAINER) use_mind = MIND_KI;
2241         else if (p_ptr->pclass == CLASS_BERSERKER) use_mind = MIND_BERSERKER;
2242         else if (p_ptr->pclass == CLASS_NINJA) use_mind = MIND_NINJUTSU;
2243         else if (p_ptr->pclass == CLASS_MIRROR_MASTER)
2244           use_mind = MIND_MIRROR_MASTER;
2245
2246         screen_save();
2247
2248         while(1)
2249         {
2250                 /* get power */
2251                 if (!get_mind_power(&n, TRUE))
2252                 {
2253                         screen_load();
2254                         return;
2255                 }
2256
2257                 /* Clear lines, position cursor  (really should use strlen here) */
2258                 Term_erase(12, 21, 255);
2259                 Term_erase(12, 20, 255);
2260                 Term_erase(12, 19, 255);
2261                 Term_erase(12, 18, 255);
2262                 Term_erase(12, 17, 255);
2263                 Term_erase(12, 16, 255);
2264
2265                 roff_to_buf(mind_tips[use_mind][n], 62, temp, sizeof(temp));
2266                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
2267                 {
2268                         prt(&temp[j], line, 15);
2269                         line++;
2270                 }
2271                 switch (use_mind)
2272                 {
2273                 case MIND_MIRROR_MASTER:
2274                 case MIND_NINJUTSU:
2275 #ifdef JP
2276                   prt("²¿¤«¥¡¼¤ò²¡¤·¤Æ²¼¤µ¤¤¡£",0,0);
2277 #else
2278                   prt("Hit any key.",0,0);
2279 #endif
2280                   (void)inkey();
2281                 }
2282         }
2283 }