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²ó", (long int)(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, 0L);
 893                 break;
 894         case 3:
 895                 /* Major displace */
 896                 teleport_player(plev * 5, 0L);
 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                 int m_idx;
1170
1171                 if (!target_set(TARGET_KILL)) return FALSE;
1172                 m_idx = cave[target_row][target_col].m_idx;
1173                 if (!m_idx) break;
1174                 if (!player_has_los_bold(target_row, target_col)) break;
1175                 if (!projectable(py, px, target_row, target_col)) break;
1176                 dispel_monster_status(m_idx);
1177                 break;
1178         }
1179         case 10:
1180         {
1181                 int i;
1182                 bool success = FALSE;
1183
1184                 for (i = 0; i < 1 + boost/100; i++)
1185                         if (summon_specific(-1, py, px, plev, SUMMON_PHANTOM, PM_FORCE_PET))
1186                                 success = TRUE;
1187                 if (success)
1188                 {
1189 #ifdef JP
1190 msg_print("¸æÍÑ¤Ç¤´¤¶¤¤¤Þ¤¹¤¬¡¢¸æ¼ç¿ÍÍÍ¡©");
1191 #else
1192                         msg_print("'Your wish, master?'");
1193 #endif
1194                 }
1195                 else
1196                 {
1197 #ifdef JP
1198                         msg_print("²¿¤â¸½¤ì¤Ê¤«¤Ã¤¿¡£");
1199 #else
1200                         msg_print("Nothing happen.");
1201 #endif
1202                 }
1203                 break;
1204         }
1205         case 11:
1206                 fire_ball(GF_FIRE, 0, 200 + (2 * plev) + boost * 2, 10);
1207                 break;
1208         case 12:
1209                 if (!get_aim_dir(&dir)) return FALSE;
1210
1211                 fire_beam(GF_MANA, dir, damroll(10 + (plev / 2) + boost * 3 / 10, 15));
1212                 break;
1213         case 13:
1214                 set_lightspeed(randint1(16) + 16 + boost / 20, FALSE);
1215                 break;
1216         default:
1217 #ifdef JP
1218 msg_print("¤Ê¤Ë¡©");
1219 #else
1220                 msg_print("Zap?");
1221 #endif
1222
1223         }
1224         p_ptr->magic_num1[0] = 0;
1225         p_ptr->update |= (PU_BONUS);
1226
1227         return TRUE;
1228 }
1229
1230 /* by henkma */
1231 /* calculate mirrors */
1232 static int number_of_mirrors( void )
1233 {
1234   int x,y;
1235   int val=0;
1236   for( x=0 ; x < cur_wid ; x++ ){
1237     for( y=0 ; y < cur_hgt ; y++ ){
1238       if (is_mirror_grid(&cave[y][x])) val++;
1239     }
1240   }
1241   return val;
1242 }
1243
1244 static bool cast_mirror_spell(int spell)
1245 {
1246         int             dir;
1247         int             plev = p_ptr->lev;
1248         int             tmp;
1249         int             x,y;
1250
1251         /* spell code */
1252         switch (spell)
1253         {
1254         /* mirror of seeing */
1255         case 0:
1256           tmp = is_mirror_grid(&cave[py][px]) ? 4 : 0;
1257           if( plev + tmp > 4)detect_monsters_normal(DETECT_RAD_DEFAULT);
1258           if( plev + tmp > 18 )detect_monsters_invis(DETECT_RAD_DEFAULT);
1259           if( plev + tmp > 28 )set_tim_esp(plev,FALSE);
1260           if( plev + tmp > 38 )map_area(DETECT_RAD_MAP);
1261           if( tmp == 0 && plev < 5 ){
1262 #ifdef JP
1263             msg_print("¶À¤¬¤Ê¤¯¤Æ½¸Ãæ¤Ç¤¤Ê¤«¤Ã¤¿¡ª");
1264 #else
1265             msg_print("You need a mirror to concentrate!");
1266 #endif
1267           }
1268           break;
1269         /* drip of light */
1270         case 1:
1271           if( number_of_mirrors() < 4 + plev/10 ){
1272             place_mirror();
1273           }
1274           else {
1275 #ifdef JP
1276 msg_format("¤³¤ì°Ê¾å¶À¤ÏÀ©¸æ¤Ç¤¤Ê¤¤¡ª");
1277 #else
1278 msg_format("There are too many mirrors to control!");
1279 #endif
1280           }
1281           break;
1282         case 2:
1283           if (!get_aim_dir(&dir)) return FALSE;
1284           if ( plev > 9 && is_mirror_grid(&cave[py][px]) ) {
1285             fire_beam(GF_LITE, dir,damroll(3+((plev-1)/5),4));
1286           }
1287           else {
1288             fire_bolt(GF_LITE, dir,damroll(3+((plev-1)/5),4));
1289           }
1290           break;
1291         /* warped mirror */
1292         case 3:
1293           teleport_player(10, 0L);
1294           break;
1295         /* mirror of light */
1296         case 4:
1297           (void)lite_area(damroll(2, (plev / 2)), (plev / 10) + 1);
1298           break;
1299         /* mirror of wandering */
1300         case 5:
1301           teleport_player(plev * 5, 0L);
1302           break;
1303         /* robe of dust */
1304         case 6:
1305           set_dustrobe(20+randint1(20),FALSE);
1306           break;
1307         /* banishing mirror */
1308         case 7:
1309           if (!get_aim_dir(&dir)) return FALSE;
1310           (void)fire_beam(GF_AWAY_ALL, dir , plev);
1311           break;
1312         /* mirror clashing */
1313         case 8:
1314           if (!get_aim_dir(&dir)) return FALSE;
1315           fire_ball(GF_SHARDS, dir, damroll(8 + ((plev - 5) / 4), 8),
1316                     (plev > 20 ? (plev - 20) / 8 + 1 : 0));
1317           break;
1318         /* mirror sleeping */
1319         case 9:
1320           for(x=0;x<cur_wid;x++){
1321             for(y=0;y<cur_hgt;y++){
1322               if (is_mirror_grid(&cave[y][x])) {
1323                 project(0,2,y,x,plev,GF_OLD_SLEEP,(PROJECT_GRID|PROJECT_ITEM|PROJECT_KILL|PROJECT_JUMP|PROJECT_NO_HANGEKI),-1);
1324               }
1325             }
1326           }
1327           break;
1328         /* seeker ray */
1329         case 10:
1330           if (!get_aim_dir(&dir)) return FALSE;
1331           fire_beam(GF_SEEKER,dir, damroll(11+(plev-5)/4,8));
1332           break;
1333         /* seal of mirror */
1334         case 11:
1335           seal_of_mirror(plev*4+100);
1336           break;
1337         /* shield of water */
1338         case 12:
1339           tmp = 20+randint1(20);
1340           set_shield(tmp, FALSE);
1341           if( plev > 31 )set_tim_reflect(tmp, FALSE);
1342           if( plev > 39 )set_resist_magic(tmp,FALSE);
1343           break;
1344         /* super ray */
1345         case 13:
1346           if (!get_aim_dir(&dir)) return FALSE;
1347           fire_beam(GF_SUPER_RAY,dir, 150+randint1(2*plev));
1348           break;
1349         /* illusion light */
1350         case 14:
1351           tmp = is_mirror_grid(&cave[py][px]) ? 4 : 3;
1352           slow_monsters();
1353           stun_monsters(plev*tmp);
1354           confuse_monsters(plev*tmp);
1355           turn_monsters(plev*tmp);
1356           stun_monsters(plev*tmp);
1357           stasis_monsters(plev*tmp);
1358           break;
1359         /* mirror shift */
1360         case 15:
1361           if( !is_mirror_grid(&cave[py][px]) ){
1362 #ifdef JP
1363                 msg_print("¶À¤Î¹ñ¤Î¾ì½ê¤¬¤ï¤«¤é¤Ê¤¤¡ª");
1364 #else
1365                 msg_print("You cannot find out where is the world of mirror!");
1366 #endif
1367                 break;
1368           }
1369           alter_reality();
1370           break;
1371         /* mirror tunnel */
1372         case 16:
1373 #ifdef JP
1374           msg_print("¶À¤ÎÀ¤³¦¤òÄÌ¤êÈ´¤±¡Ä  ");
1375 #else
1376           msg_print("Go through the world of mirror...");
1377 #endif
1378           return mirror_tunnel();
1379
1380         /* mirror of recall */
1381         case 17:
1382                 return word_of_recall();
1383         /* multi-shadow */
1384         case 18:
1385           set_multishadow(6+randint1(6),FALSE);
1386           break;
1387         /* binding field */
1388         case 19:
1389 #ifdef JP
1390           if( !binding_field(plev*11+5) )msg_print("Å¬Åö¤Ê¶À¤òÁª¤Ù¤Ê¤«¤Ã¤¿¡ª");
1391 #else
1392           if( !binding_field(plev*11+5) )msg_print("You were not able to choose suitable mirrors!");
1393 #endif
1394           break;
1395         /* mirror of Ruffnor */
1396         case 20:
1397           (void)set_invuln(randint1(4)+4,FALSE);
1398           break;
1399         default:
1400 #ifdef JP
1401 msg_print("¤Ê¤Ë¡©");
1402 #else
1403                 msg_print("Zap?");
1404 #endif
1405
1406         }
1407         p_ptr->magic_num1[0] = 0;
1408
1409         return TRUE;
1410 }
1411
1412
1413 /*
1414  * do_cmd_cast calls this function if the player's class
1415  * is 'berserker'.
1416  */
1417 static bool cast_berserk_spell(int spell)
1418 {
1419         int y, x;
1420         int dir;
1421
1422         /* spell code */
1423         switch (spell)
1424         {
1425         case 0:
1426                 detect_monsters_mind(DETECT_RAD_DEFAULT);
1427                 break;
1428         case 1:
1429         {
1430                 if (p_ptr->riding)
1431                 {
1432 #ifdef JP
1433                         msg_print("¾èÇÏÃæ¤Ë¤ÏÌµÍý¤À¡£");
1434 #else
1435                         msg_print("You cannot do it when riding.");
1436 #endif
1437                         return FALSE;
1438                 }
1439
1440                 if (!get_rep_dir2(&dir)) return FALSE;
1441
1442                 if (dir == 5) return FALSE;
1443                 y = py + ddy[dir];
1444                 x = px + ddx[dir];
1445
1446                 if (!cave[y][x].m_idx)
1447                 {
1448 #ifdef JP
1449                         msg_print("¤½¤ÎÊý¸þ¤Ë¤Ï¥â¥ó¥¹¥¿¡¼¤Ï¤¤¤Þ¤»¤ó¡£");
1450 #else
1451                         msg_print("There is no monster.");
1452 #endif
1453                         return FALSE;
1454                 }
1455
1456                 py_attack(y, x, 0);
1457
1458                 if (!player_can_enter(cave[y][x].feat, 0) || is_trap(cave[y][x].feat))
1459                         break;
1460
1461                 y += ddy[dir];
1462                 x += ddx[dir];
1463
1464                 if (player_can_enter(cave[y][x].feat, 0) && !is_trap(cave[y][x].feat) && !cave[y][x].m_idx)
1465                 {
1466                         msg_print(NULL);
1467
1468                         /* Move the player */
1469                         (void)move_player_effect(y, x, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
1470                 }
1471                 break;
1472         }
1473         case 2:
1474         {
1475                 if (!get_rep_dir2(&dir)) return FALSE;
1476                 y = py + ddy[dir];
1477                 x = px + ddx[dir];
1478                 move_player(dir, easy_disarm, TRUE);
1479                 break;
1480         }
1481         case 3:
1482                 earthquake(py, px, 8+randint0(5));
1483                 break;
1484         case 4:
1485         {
1486                 cave_type       *c_ptr;
1487                 monster_type    *m_ptr;
1488
1489                 for (dir = 0; dir < 8; dir++)
1490                 {
1491                         y = py + ddy_ddd[dir];
1492                         x = px + ddx_ddd[dir];
1493                         c_ptr = &cave[y][x];
1494
1495                         /* Get the monster */
1496                         m_ptr = &m_list[c_ptr->m_idx];
1497
1498                         /* Hack -- attack monsters */
1499                         if (c_ptr->m_idx && (m_ptr->ml || cave_have_flag_bold(y, x, FF_PROJECT)))
1500                                 py_attack(y, x, 0);
1501                 }
1502                 break;
1503         }
1504         default:
1505 #ifdef JP
1506 msg_print("¤Ê¤Ë¡©");
1507 #else
1508                 msg_print("Zap?");
1509 #endif
1510
1511         }
1512         return TRUE;
1513 }
1514
1515
1516
1517 /*
1518  * do_cmd_cast calls this function if the player's class
1519  * is 'ninja'.
1520  */
1521 static bool cast_ninja_spell(int spell)
1522 {
1523         int x, y;
1524         int dir;
1525         int plev = p_ptr->lev;
1526
1527         /* spell code */
1528         switch (spell)
1529         {
1530         case 0:
1531                 (void)unlite_area(0, 3);
1532                 break;
1533         case 1:
1534                 if (plev > 44)
1535                 {
1536                         wiz_lite(TRUE);
1537                 }
1538                 detect_monsters_normal(DETECT_RAD_DEFAULT);
1539                 if (plev > 4)
1540                 {
1541                         detect_traps(DETECT_RAD_DEFAULT, TRUE);
1542                         detect_doors(DETECT_RAD_DEFAULT);
1543                         detect_stairs(DETECT_RAD_DEFAULT);
1544                 }
1545                 if (plev > 14)
1546                 {
1547                         detect_objects_normal(DETECT_RAD_DEFAULT);
1548                 }
1549                 break;
1550         case 2:
1551         {
1552                 teleport_player(10, 0L);
1553                 break;
1554         }
1555         case 3:
1556         {
1557                 if (!(p_ptr->special_defense & NINJA_KAWARIMI))
1558                 {
1559 #ifdef JP
1560                         msg_print("Å¨¤Î¹¶·â¤ËÂÐ¤·¤ÆÉÒ´¶¤Ë¤Ê¤Ã¤¿¡£");
1561 #else
1562                         msg_print("You are now prepare to evade any attacks.");
1563 #endif
1564
1565                         p_ptr->special_defense |= NINJA_KAWARIMI;
1566                         p_ptr->redraw |= (PR_STATUS);
1567                 }
1568                 break;
1569         }
1570         case 4:
1571         {
1572                 teleport_player(p_ptr->lev * 5, 0L);
1573                 break;
1574         }
1575         case 5:
1576         {
1577                 if (!get_rep_dir(&dir, FALSE)) return FALSE;
1578                 y = py + ddy[dir];
1579                 x = px + ddx[dir];
1580                 if (cave[y][x].m_idx)
1581                 {
1582                         py_attack(y, x, 0);
1583                         if (randint0(p_ptr->skill_dis) < 7)
1584 #ifdef JP
1585 msg_print("¤¦¤Þ¤¯Æ¨¤²¤é¤ì¤Ê¤«¤Ã¤¿¡£");
1586 #else
1587                                 msg_print("You failed to run away.");
1588 #endif
1589                         else
1590                         {
1591                                 teleport_player(30, 0L);
1592                         }
1593                 }
1594                 else
1595                 {
1596 #ifdef JP
1597 msg_print("¤½¤ÎÊý¸þ¤Ë¤Ï¥â¥ó¥¹¥¿¡¼¤Ï¤¤¤Þ¤»¤ó¡£");
1598 #else
1599                         msg_print("You don't see any monster in this direction");
1600 #endif
1601
1602                         msg_print(NULL);
1603                 }
1604                 break;
1605         }
1606         case 6:
1607         {
1608                 if (!get_aim_dir(&dir)) return FALSE;
1609                 (void)stasis_monster(dir);
1610                 break;
1611         }
1612         case 7:
1613                 return ident_spell(FALSE);
1614         case 8:
1615                 set_tim_levitation(randint1(20) + 20, FALSE);
1616                 break;
1617         case 9:
1618                 fire_ball(GF_FIRE, 0, 50+plev, plev/10+2);
1619                 teleport_player(30, 0L);
1620                 set_oppose_fire(plev, FALSE);
1621                 break;
1622         case 10:
1623                 return rush_attack(NULL);
1624         case 11:
1625         {
1626                 int i;
1627                 for (i = 0; i < 8; i++)
1628                 {
1629                         int slot;
1630
1631                         for (slot = 0; slot < INVEN_PACK; slot++)
1632                         {
1633                                 if (inventory[slot].tval == TV_SPIKE) break;
1634                         }
1635                         if (slot == INVEN_PACK)
1636                         {
1637 #ifdef JP
1638                                 if (!i) msg_print("¤¯¤µ¤Ó¤ò»ý¤Ã¤Æ¤¤¤Ê¤¤¡£");
1639                                 else msg_print("¤¯¤µ¤Ó¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
1640 #else
1641                                 if (!i) msg_print("You have no Iron Spikes.");
1642                                 else msg_print("You have no more Iron Spikes.");
1643 #endif
1644                                 return FALSE;
1645                         }
1646
1647                         /* Gives a multiplier of 2 at first, up to 3 at 40th */
1648                         do_cmd_throw_aux(1, FALSE, slot);
1649
1650                         energy_use = 100;
1651                 }
1652                 break;
1653         }
1654         case 12:
1655         {
1656                 monster_type *m_ptr;
1657                 int m_idx;
1658                 char m_name[80];
1659                 int i;
1660                 int path_n;
1661                 u16b path_g[512];
1662                 int ty,tx;
1663
1664                 if (!target_set(TARGET_KILL)) return FALSE;
1665                 m_idx = cave[target_row][target_col].m_idx;
1666                 if (!m_idx) break;
1667                 if (m_idx == p_ptr->riding) break;
1668                 if (!player_has_los_bold(target_row, target_col)) break;
1669                 if (!projectable(py, px, target_row, target_col)) break;
1670                 m_ptr = &m_list[m_idx];
1671                 monster_desc(m_name, m_ptr, 0);
1672 #ifdef JP
1673                 msg_format("%s¤ò°ú¤Ìá¤·¤¿¡£", m_name);
1674 #else
1675                 msg_format("You pull back %s.", m_name);
1676 #endif
1677
1678                 path_n = project_path(path_g, MAX_RANGE, target_row, target_col, py, px, 0);
1679                 ty = target_row, tx = target_col;
1680                 for (i = 1; i < path_n; i++)
1681                 {
1682                         int ny = GRID_Y(path_g[i]);
1683                         int nx = GRID_X(path_g[i]);
1684                         cave_type *c_ptr = &cave[ny][nx];
1685
1686                         if (in_bounds(ny, nx) && cave_empty_bold(ny, nx) &&
1687                             !(c_ptr->info & CAVE_OBJECT) &&
1688                                 !pattern_tile(ny, nx))
1689                         {
1690                                 ty = ny;
1691                                 tx = nx;
1692                         }
1693                 }
1694                 /* Update the old location */
1695                 cave[target_row][target_col].m_idx = 0;
1696
1697                 /* Update the new location */
1698                 cave[ty][tx].m_idx = m_idx;
1699
1700                 /* Move the monster */
1701                 m_ptr->fy = ty;
1702                 m_ptr->fx = tx;
1703
1704                 /* Wake the monster up */
1705                 (void)set_monster_csleep(m_idx, 0);
1706
1707                 /* Update the monster (new location) */
1708                 update_mon(m_idx, TRUE);
1709
1710                 /* Redraw the old grid */
1711                 lite_spot(target_row, target_col);
1712
1713                 /* Redraw the new grid */
1714                 lite_spot(ty, tx);
1715
1716                 if (r_info[m_ptr->r_idx].flags7 & (RF7_LITE_MASK | RF7_DARK_MASK))
1717                         p_ptr->update |= (PU_MON_LITE);
1718
1719                 if (m_ptr->ml)
1720                 {
1721                         /* Auto-Recall if possible and visible */
1722                         if (!p_ptr->image) monster_race_track(m_ptr->ap_r_idx);
1723
1724                         /* Track a new monster */
1725                         health_track(m_idx);
1726                 }
1727
1728                 break;
1729         }
1730         case 13:
1731                 if (!get_aim_dir(&dir)) return FALSE;
1732                 fire_ball(GF_OLD_CONF, dir, plev*3, 3);
1733                 break;
1734         case 14:
1735                 project_length = -1;
1736                 if (!get_aim_dir(&dir))
1737                 {
1738                         project_length = 0;
1739                         return FALSE;
1740                 }
1741                 project_length = 0;
1742
1743                 (void)teleport_swap(dir);
1744                 break;
1745         case 15:
1746                 explosive_rune();
1747                 break;
1748         case 16:
1749                 (void)set_kabenuke(randint1(plev/2) + plev/2, FALSE);
1750                 set_oppose_acid(plev, FALSE);
1751                 break;
1752         case 17:
1753                 fire_ball(GF_POIS, 0, 75+plev*2/3, plev/5+2);
1754                 fire_ball(GF_OLD_DRAIN, 0, 75+plev*2/3, plev/5+2);
1755                 fire_ball(GF_CONFUSION, 0, 75+plev*2/3, plev/5+2);
1756                 teleport_player(30, 0L);
1757                 break;
1758         case 18:
1759         {
1760                 int k;
1761                 int num = damroll(3, 9);
1762
1763                 for (k = 0; k < num; k++)
1764                 {
1765                         int typ = one_in_(2) ? GF_FIRE : one_in_(3) ? GF_NETHER : GF_PLASMA;
1766                         int attempts = 1000;
1767
1768                         while (attempts--)
1769                         {
1770                                 scatter(&y, &x, py, px, 4, 0);
1771
1772                                 if (!player_bold(y, x)) break;
1773                         }
1774                         project(0, 0, y, x, damroll(6 + plev / 8, 10), typ,
1775                                 (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_KILL), -1);
1776                 }
1777                 break;
1778         }
1779         case 19:
1780                 set_multishadow(6+randint1(6), FALSE);
1781                 break;
1782         default:
1783 #ifdef JP
1784 msg_print("¤Ê¤Ë¡©");
1785 #else
1786                 msg_print("Zap?");
1787 #endif
1788
1789         }
1790         return TRUE;
1791 }
1792
1793
1794
1795 /*
1796  * do_cmd_cast calls this function if the player's class
1797  * is 'mindcrafter'.
1798  */
1799 void do_cmd_mind(void)
1800 {
1801         int             n = 0,  b = 0;
1802         int             chance;
1803         int             minfail = 0;
1804         int             plev = p_ptr->lev;
1805         int             old_csp = p_ptr->csp;
1806         mind_type       spell;
1807         bool            cast;
1808         int             use_mind, mana_cost;
1809 #ifdef JP
1810         cptr            p;
1811 #endif
1812         bool            on_mirror = FALSE;
1813
1814         /* not if confused */
1815         if (p_ptr->confused)
1816         {
1817 #ifdef JP
1818 msg_print("º®Íð¤·¤Æ¤¤¤Æ½¸Ãæ¤Ç¤¤Ê¤¤¡ª");
1819 #else
1820                 msg_print("You are too confused!");
1821 #endif
1822
1823                 return;
1824         }
1825
1826         /* get power */
1827         if (!get_mind_power(&n, FALSE)) return;
1828
1829 #ifdef JP
1830         switch(p_ptr->pclass)
1831         {
1832                 case CLASS_MINDCRAFTER: use_mind = MIND_MINDCRAFTER;p = "Àº¿À";break;
1833                 case CLASS_FORCETRAINER:          use_mind = MIND_KI;p = "µ¤";break;
1834                 case CLASS_BERSERKER:   use_mind = MIND_BERSERKER;p = "ÅÜ¤ê";break;
1835                 case CLASS_MIRROR_MASTER:   use_mind = MIND_MIRROR_MASTER;p = "¶ÀËâË¡";break;
1836                 case CLASS_NINJA:       use_mind = MIND_NINJUTSU;p = "Àº¿À";break;
1837                 default:                use_mind = 0;p = "Ä¶Ç½ÎÏ";break;
1838         }
1839 #else
1840         switch(p_ptr->pclass)
1841         {
1842                 case CLASS_MINDCRAFTER: use_mind = MIND_MINDCRAFTER;break;
1843                 case CLASS_FORCETRAINER:          use_mind = MIND_KI;break;
1844                 case CLASS_BERSERKER:   use_mind = MIND_BERSERKER;break;
1845                 case CLASS_MIRROR_MASTER:   use_mind = MIND_MIRROR_MASTER;break;
1846                 case CLASS_NINJA:       use_mind = MIND_NINJUTSU;break;
1847                 default:                use_mind = 0;break;
1848         }
1849 #endif
1850         spell = mind_powers[use_mind].info[n];
1851
1852         /* Spell failure chance */
1853         chance = spell.fail;
1854
1855         mana_cost = spell.mana_cost;
1856         if (use_mind == MIND_KI)
1857         {
1858                 if (heavy_armor()) chance += 20;
1859                 if (p_ptr->icky_wield[0]) chance += 20;
1860                 else if (buki_motteruka(INVEN_RARM)) chance += 10;
1861                 if (p_ptr->icky_wield[1]) chance += 20;
1862                 else if (buki_motteruka(INVEN_LARM)) chance += 10;
1863                 if (n == 5)
1864                 {
1865                         int j;
1866                         for (j = 0; j < p_ptr->magic_num1[0] / 50; j++)
1867                                 mana_cost += (j+1) * 3 / 2;
1868                 }
1869         }
1870
1871         /* Verify "dangerous" spells */
1872         if ((use_mind == MIND_BERSERKER) || (use_mind == MIND_NINJUTSU))
1873         {
1874                 if (mana_cost > p_ptr->chp)
1875                 {
1876 #ifdef JP
1877 msg_print("£È£Ð¤¬Â¤ê¤Þ¤»¤ó¡£");
1878 #else
1879                         msg_print("You do not have enough hp to use this power.");
1880 #endif
1881                         return;
1882                 }
1883         }
1884         else if (mana_cost > p_ptr->csp)
1885         {
1886                 /* Warning */
1887 #ifdef JP
1888 msg_print("£Í£Ð¤¬Â¤ê¤Þ¤»¤ó¡£");
1889 #else
1890                 msg_print("You do not have enough mana to use this power.");
1891 #endif
1892
1893
1894                 if (!over_exert) return;
1895
1896                 /* Verify */
1897 #ifdef JP
1898 if (!get_check("¤½¤ì¤Ç¤âÄ©Àï¤·¤Þ¤¹¤«? ")) return;
1899 #else
1900                 if (!get_check("Attempt it anyway? ")) return;
1901 #endif
1902
1903         }
1904
1905         if (chance)
1906         {
1907                 /* Reduce failure rate by "effective" level adjustment */
1908                 chance -= 3 * (plev - spell.min_lev);
1909
1910                 chance += p_ptr->to_m_chance;
1911
1912                 /* Reduce failure rate by INT/WIS adjustment */
1913                 chance -= 3 * (adj_mag_stat[p_ptr->stat_ind[mp_ptr->spell_stat]] - 1);
1914
1915                 /* Not enough mana to cast */
1916                 if ((mana_cost > p_ptr->csp) && (use_mind != MIND_BERSERKER) && (use_mind != MIND_NINJUTSU))
1917                 {
1918                         chance += 5 * (mana_cost - p_ptr->csp);
1919                 }
1920
1921                 /* Extract the minimum failure rate */
1922                 minfail = adj_mag_fail[p_ptr->stat_ind[mp_ptr->spell_stat]];
1923
1924                 /* Minimum failure rate */
1925                 if (chance < minfail) chance = minfail;
1926
1927                 /* Stunning makes spells harder */
1928                 if (p_ptr->stun > 50) chance += 25;
1929                 else if (p_ptr->stun) chance += 15;
1930
1931                 if (use_mind == MIND_KI)
1932                 {
1933                         if (heavy_armor()) chance += 5;
1934                         if (p_ptr->icky_wield[0]) chance += 5;
1935                         if (p_ptr->icky_wield[1]) chance += 5;
1936                 }
1937         }
1938
1939         /* Always a 5 percent chance of working */
1940         if (chance > 95) chance = 95;
1941
1942         /* Failed spell */
1943         if (randint0(100) < chance)
1944         {
1945                 if (flush_failure) flush();
1946 #ifdef JP
1947 msg_format("%s¤Î½¸Ãæ¤Ë¼ºÇÔ¤·¤¿¡ª",p);
1948 #else
1949                 msg_format("You failed to concentrate hard enough!");
1950 #endif
1951
1952                 sound(SOUND_FAIL);
1953
1954                 if ((use_mind != MIND_BERSERKER) && (use_mind != MIND_NINJUTSU))
1955                 {
1956                         if ((use_mind == MIND_KI) && (n != 5) && p_ptr->magic_num1[0])
1957                         {
1958 #ifdef JP
1959                                 msg_print("µ¤¤¬»¶¤Ã¤Æ¤·¤Þ¤Ã¤¿¡¥¡¥¡¥");
1960 #else
1961                                 msg_print("Your improved Force has gone away...");
1962 #endif
1963                                 p_ptr->magic_num1[0] = 0;
1964                         }
1965
1966                         if (randint1(100) < (chance / 2))
1967                         {
1968                                 /* Backfire */
1969                           b = randint1(100);
1970
1971                           if( use_mind == MIND_MINDCRAFTER ){
1972                                 if (b < 5)
1973                                 {
1974 #ifdef JP
1975 msg_print("¤Ê¤ó¤Æ¤³¤Ã¤¿¡ªÆ¬¤ÎÃæ¤¬¿¿¤ÃÇò¤Ë¤Ê¤Ã¤¿¡ª");
1976 #else
1977                                         msg_print("Oh, no! Your mind has gone blank!");
1978 #endif
1979
1980                                         lose_all_info();
1981                                 }
1982                                 else if (b < 15)
1983                                 {
1984 #ifdef JP
1985 msg_print("´ñÌ¯¤Ê¸÷·Ê¤¬ÌÜ¤ÎÁ°¤ÇÍÙ¤Ã¤Æ¤¤¤ë...");
1986 #else
1987                                         msg_print("Weird visions seem to dance before your eyes...");
1988 #endif
1989
1990                                         set_image(p_ptr->image + 5 + randint1(10));
1991                                 }
1992                                 else if (b < 45)
1993                                 {
1994 #ifdef JP
1995 msg_print("¤¢¤Ê¤¿¤ÎÆ¬¤Ïº®Íð¤·¤¿¡ª");
1996 #else
1997                                         msg_print("Your brain is addled!");
1998 #endif
1999
2000                                         set_confused(p_ptr->confused + randint1(8));
2001                                 }
2002                                 else if (b < 90)
2003                                 {
2004                                         set_stun(p_ptr->stun + randint1(8));
2005                                 }
2006                                 else
2007                                 {
2008                                         /* Mana storm */
2009 #ifdef JP
2010 msg_format("%s¤ÎÎÏ¤¬À©¸æ¤Ç¤¤Ê¤¤ÈÅÎ®¤È¤Ê¤Ã¤Æ²òÊü¤µ¤ì¤¿¡ª", p);
2011 #else
2012                                         msg_print("Your mind unleashes its power in an uncontrollable storm!");
2013 #endif
2014
2015                                         project(PROJECT_WHO_UNCTRL_POWER, 2 + plev / 10, py, px, plev * 2,
2016                                                 GF_MANA, PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM, -1);
2017                                         p_ptr->csp = MAX(0, p_ptr->csp - plev * MAX(1, plev / 10));
2018                                 }
2019                           }
2020                           if( use_mind == MIND_MIRROR_MASTER ){
2021                                 if (b < 51)
2022                                 {
2023                                   /* Nothing has happen */
2024                                 }
2025                                 else if (b < 81)
2026                                 {
2027 #ifdef JP
2028 msg_print("¶À¤ÎÀ¤³¦¤Î´³¾Ä¤ò¼õ¤±¤¿¡ª");
2029 #else
2030                                         msg_print("Weird visions seem to dance before your eyes...");
2031 #endif
2032                                         teleport_player(10, TELEPORT_PASSIVE);
2033                                 }
2034                                 else if (b < 96)
2035                                 {
2036 #ifdef JP
2037 msg_print("¤Þ¤ï¤ê¤Î¤â¤Î¤¬¥¥é¥¥éµ±¤¤¤Æ¤¤¤ë¡ª");
2038 #else
2039                                         msg_print("Your brain is addled!");
2040 #endif
2041
2042                                         set_image(p_ptr->image + 5 + randint1(10));
2043                                 }
2044                                 else
2045                                 {
2046                                         /* Mana storm */
2047 #ifdef JP
2048 msg_format("%s¤ÎÎÏ¤¬À©¸æ¤Ç¤¤Ê¤¤ÈÅÎ®¤È¤Ê¤Ã¤Æ²òÊü¤µ¤ì¤¿¡ª", p);
2049 #else
2050                                         msg_print("Your mind unleashes its power in an uncontrollable storm!");
2051 #endif
2052
2053                                         project(PROJECT_WHO_UNCTRL_POWER, 2 + plev / 10, py, px, plev * 2,
2054                                                 GF_MANA, PROJECT_JUMP | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM, -1);
2055                                         p_ptr->csp = MAX(0, p_ptr->csp - plev * MAX(1, plev / 10));
2056                                 }
2057                           }
2058                         }
2059                 }
2060         }
2061         else
2062         {
2063                 sound(SOUND_ZAP);
2064
2065                 switch(use_mind)
2066                 {
2067                 case MIND_MINDCRAFTER:
2068                         /* Cast the spell */
2069                         cast = cast_mindcrafter_spell(n);
2070                         break;
2071                 case MIND_KI:
2072                         /* Cast the spell */
2073                         cast = cast_force_spell(n);
2074                         break;
2075                 case MIND_BERSERKER:
2076                         /* Cast the spell */
2077                         cast = cast_berserk_spell(n);
2078                         break;
2079                 case MIND_MIRROR_MASTER:
2080                         /* Cast the spell */
2081                         if( is_mirror_grid(&cave[py][px]) )on_mirror = TRUE;
2082                         cast = cast_mirror_spell(n);
2083                         break;
2084                 case MIND_NINJUTSU:
2085                         /* Cast the spell */
2086                         cast = cast_ninja_spell(n);
2087                         break;
2088                 default:
2089 #ifdef JP
2090                         msg_format("Ææ¤ÎÇ½ÎÏ:%d, %d",use_mind, n);
2091 #else
2092                         msg_format("Mystery power:%d, %d",use_mind, n);
2093 #endif
2094                         return;
2095                 }
2096
2097                 if (!cast) return;
2098         }
2099
2100
2101         /* Take a turn */
2102         energy_use = 100;
2103         /* teleport from mirror costs small energy */
2104         if( on_mirror && p_ptr->pclass == CLASS_MIRROR_MASTER )
2105         {
2106           if( n==3 || n==5 || n==7 || n==16 )energy_use = 50;
2107         }
2108
2109         if ((use_mind == MIND_BERSERKER) || (use_mind == MIND_NINJUTSU))
2110         {
2111 #ifdef JP
2112                 take_hit(DAMAGE_USELIFE, mana_cost, "²áÅÙ¤Î½¸Ãæ", -1);
2113 #else
2114                 take_hit(DAMAGE_USELIFE, mana_cost, "concentrating too hard", -1);
2115 #endif
2116                 /* Redraw hp */
2117                 p_ptr->redraw |= (PR_HP);
2118         }
2119
2120         /* Sufficient mana */
2121         else if (mana_cost <= old_csp)
2122         {
2123                 /* Use some mana */
2124                 p_ptr->csp -= mana_cost;
2125
2126                 /* Limit */
2127                 if (p_ptr->csp < 0) p_ptr->csp = 0;
2128
2129                 if ((use_mind == MIND_MINDCRAFTER) && (n == 13))
2130                 {
2131                         /* No mana left */
2132                         p_ptr->csp = 0;
2133                         p_ptr->csp_frac = 0;
2134                 }
2135         }
2136
2137         /* Over-exert the player */
2138         else
2139         {
2140                 int oops = mana_cost - old_csp;
2141
2142                 /* No mana left */
2143                 if ((p_ptr->csp - mana_cost) < 0) p_ptr->csp_frac = 0;
2144                 p_ptr->csp = MAX(0, p_ptr->csp - mana_cost);
2145
2146                 /* Message */
2147 #ifdef JP
2148 msg_format("%s¤ò½¸Ãæ¤·¤¹¤®¤Æµ¤¤ò¼º¤Ã¤Æ¤·¤Þ¤Ã¤¿¡ª",p);
2149 #else
2150                 msg_print("You faint from the effort!");
2151 #endif
2152
2153
2154                 /* Hack -- Bypass free action */
2155                 (void)set_paralyzed(p_ptr->paralyzed + randint1(5 * oops + 1));
2156
2157                 /* Damage WIS (possibly permanently) */
2158                 if (randint0(100) < 50)
2159                 {
2160                         bool perm = (randint0(100) < 25);
2161
2162                         /* Message */
2163 #ifdef JP
2164 msg_print("¼«Ê¬¤ÎÀº¿À¤ò¹¶·â¤·¤Æ¤·¤Þ¤Ã¤¿¡ª");
2165 #else
2166                         msg_print("You have damaged your mind!");
2167 #endif
2168
2169
2170                         /* Reduce constitution */
2171                         (void)dec_stat(A_WIS, 15 + randint1(10), perm);
2172                 }
2173         }
2174
2175         /* Redraw mana */
2176         p_ptr->redraw |= (PR_MANA);
2177
2178         /* Window stuff */
2179         p_ptr->window |= (PW_PLAYER);
2180         p_ptr->window |= (PW_SPELL);
2181 }
2182
2183
2184 /*
2185  * do_cmd_cast calls this function if the player's class
2186  * is 'mindcrafter'.
2187  */
2188 void do_cmd_mind_browse(void)
2189 {
2190         int n = 0;
2191         int j, line;
2192         char temp[62*5];
2193         int use_mind = 0;
2194
2195         if (p_ptr->pclass == CLASS_MINDCRAFTER) use_mind = MIND_MINDCRAFTER;
2196         else if (p_ptr->pclass == CLASS_FORCETRAINER) use_mind = MIND_KI;
2197         else if (p_ptr->pclass == CLASS_BERSERKER) use_mind = MIND_BERSERKER;
2198         else if (p_ptr->pclass == CLASS_NINJA) use_mind = MIND_NINJUTSU;
2199         else if (p_ptr->pclass == CLASS_MIRROR_MASTER)
2200           use_mind = MIND_MIRROR_MASTER;
2201
2202         screen_save();
2203
2204         while(1)
2205         {
2206                 /* get power */
2207                 if (!get_mind_power(&n, TRUE))
2208                 {
2209                         screen_load();
2210                         return;
2211                 }
2212
2213                 /* Clear lines, position cursor  (really should use strlen here) */
2214                 Term_erase(12, 21, 255);
2215                 Term_erase(12, 20, 255);
2216                 Term_erase(12, 19, 255);
2217                 Term_erase(12, 18, 255);
2218                 Term_erase(12, 17, 255);
2219                 Term_erase(12, 16, 255);
2220
2221                 roff_to_buf(mind_tips[use_mind][n], 62, temp, sizeof(temp));
2222                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
2223                 {
2224                         prt(&temp[j], line, 15);
2225                         line++;
2226                 }
2227                 switch (use_mind)
2228                 {
2229                 case MIND_MIRROR_MASTER:
2230                 case MIND_NINJUTSU:
2231 #ifdef JP
2232                   prt("²¿¤«¥¡¼¤ò²¡¤·¤Æ²¼¤µ¤¤¡£",0,0);
2233 #else
2234                   prt("Hit any key.",0,0);
2235 #endif
2236                   (void)inkey();
2237                 }
2238         }
2239 }