src/mspells1.c

   1 /* File: mspells1.c */
   2
   3 /* Purpose: Monster spells (attack player) */
   4
   5 /*
   6  * Copyright (c) 1989 James E. Wilson, Robert A. Koeneke
   7  *
   8  * This software may be copied and distributed for educational, research, and
   9  * not for profit purposes provided that this copyright and statement are
  10  * included in all such copies.
  11  */
  12
  13 #include "angband.h"
  14
  15
  16 #ifdef DRS_SMART_OPTIONS
  17
  18 /*
  19  * And now for Intelligent monster attacks (including spells).
  20  *
  21  * Original idea and code by "DRS" (David Reeves Sward).
  22  * Major modifications by "BEN" (Ben Harrison).
  23  *
  24  * Give monsters more intelligent attack/spell selection based on
  25  * observations of previous attacks on the player, and/or by allowing
  26  * the monster to "cheat" and know the player status.
  27  *
  28  * Maintain an idea of the player status, and use that information
  29  * to occasionally eliminate "ineffective" spell attacks.  We could
  30  * also eliminate ineffective normal attacks, but there is no reason
  31  * for the monster to do this, since he gains no benefit.
  32  * Note that MINDLESS monsters are not allowed to use this code.
  33  * And non-INTELLIGENT monsters only use it partially effectively.
  34  *
  35  * Actually learn what the player resists, and use that information
  36  * to remove attacks or spells before using them.  This will require
  37  * much less space, if I am not mistaken.  Thus, each monster gets a
  38  * set of 32 bit flags, "smart", build from the various "SM_*" flags.
  39  *
  40  * This has the added advantage that attacks and spells are related.
  41  * The "smart_learn" option means that the monster "learns" the flags
  42  * that should be set, and "smart_cheat" means that he "knows" them.
  43  * So "smart_cheat" means that the "smart" field is always up to date,
  44  * while "smart_learn" means that the "smart" field is slowly learned.
  45  * Both of them have the same effect on the "choose spell" routine.
  46  */
  47
  48
  49
  50 /*
  51  * Internal probability routine
  52  */
  53 static bool int_outof(monster_race *r_ptr, int prob)
  54 {
  55         /* Non-Smart monsters are half as "smart" */
  56         if (!(r_ptr->flags2 & RF2_SMART)) prob = prob / 2;
  57
  58         /* Roll the dice */
  59         return (randint0(100) < prob);
  60 }
  61
  62
  63
  64 /*
  65  * Remove the "bad" spells from a spell list
  66  */
  67 static void remove_bad_spells(int m_idx, u32b *f4p, u32b *f5p, u32b *f6p)
  68 {
  69         monster_type *m_ptr = &m_list[m_idx];
  70         monster_race *r_ptr = &r_info[m_ptr->r_idx];
  71
  72         u32b f4 = (*f4p);
  73         u32b f5 = (*f5p);
  74         u32b f6 = (*f6p);
  75
  76         u32b smart = 0L;
  77
  78
  79         /* Too stupid to know anything */
  80         if (r_ptr->flags2 & RF2_STUPID) return;
  81
  82
  83         /* Must be cheating or learning */
  84         if (!smart_cheat && !smart_learn) return;
  85
  86
  87         /* Update acquired knowledge */
  88         if (smart_learn)
  89         {
  90                 /* Hack -- Occasionally forget player status */
  91                 if (m_ptr->smart && (randint0(100) < 1)) m_ptr->smart = 0L;
  92
  93                 /* Use the memorized flags */
  94                 smart = m_ptr->smart;
  95         }
  96
  97
  98         /* Cheat if requested */
  99         if (smart_cheat)
 100         {
 101                 /* Know basic info */
 102                 if (p_ptr->resist_acid) smart |= (SM_RES_ACID);
 103                 if (p_ptr->oppose_acid) smart |= (SM_OPP_ACID);
 104                 if (p_ptr->immune_acid) smart |= (SM_IMM_ACID);
 105                 if (p_ptr->resist_elec) smart |= (SM_RES_ELEC);
 106                 if (p_ptr->oppose_elec) smart |= (SM_OPP_ELEC);
 107                 if (p_ptr->immune_elec) smart |= (SM_IMM_ELEC);
 108                 if (p_ptr->resist_fire) smart |= (SM_RES_FIRE);
 109                 if (p_ptr->oppose_fire) smart |= (SM_OPP_FIRE);
 110                 if (p_ptr->immune_fire) smart |= (SM_IMM_FIRE);
 111                 if (p_ptr->resist_cold) smart |= (SM_RES_COLD);
 112                 if (p_ptr->oppose_cold) smart |= (SM_OPP_COLD);
 113                 if (p_ptr->immune_cold) smart |= (SM_IMM_COLD);
 114
 115                 /* Know poison info */
 116                 if (p_ptr->resist_pois) smart |= (SM_RES_POIS);
 117                 if (p_ptr->oppose_pois) smart |= (SM_OPP_POIS);
 118
 119                 /* Know special resistances */
 120                 if (p_ptr->resist_neth) smart |= (SM_RES_NETH);
 121                 if (p_ptr->resist_lite) smart |= (SM_RES_LITE);
 122                 if (p_ptr->resist_dark) smart |= (SM_RES_DARK);
 123                 if (p_ptr->resist_fear) smart |= (SM_RES_FEAR);
 124                 if (p_ptr->resist_conf) smart |= (SM_RES_CONF);
 125                 if (p_ptr->resist_chaos) smart |= (SM_RES_CHAOS);
 126                 if (p_ptr->resist_disen) smart |= (SM_RES_DISEN);
 127                 if (p_ptr->resist_blind) smart |= (SM_RES_BLIND);
 128                 if (p_ptr->resist_nexus) smart |= (SM_RES_NEXUS);
 129                 if (p_ptr->resist_sound) smart |= (SM_RES_SOUND);
 130                 if (p_ptr->resist_shard) smart |= (SM_RES_SHARD);
 131                 if (p_ptr->reflect) smart |= (SM_IMM_REFLECT);
 132
 133                 /* Know bizarre "resistances" */
 134                 if (p_ptr->free_act) smart |= (SM_IMM_FREE);
 135                 if (!p_ptr->msp) smart |= (SM_IMM_MANA);
 136         }
 137
 138
 139         /* Nothing known */
 140         if (!smart) return;
 141
 142
 143         if (smart & SM_IMM_ACID)
 144         {
 145                 f4 &= ~(RF4_BR_ACID);
 146                 f5 &= ~(RF5_BA_ACID);
 147                 f5 &= ~(RF5_BO_ACID);
 148         }
 149         else if ((smart & (SM_OPP_ACID)) && (smart & (SM_RES_ACID)))
 150         {
 151                 if (int_outof(r_ptr, 80)) f4 &= ~(RF4_BR_ACID);
 152                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BA_ACID);
 153                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BO_ACID);
 154         }
 155         else if ((smart & (SM_OPP_ACID)) || (smart & (SM_RES_ACID)))
 156         {
 157                 if (int_outof(r_ptr, 30)) f4 &= ~(RF4_BR_ACID);
 158                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BA_ACID);
 159                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BO_ACID);
 160         }
 161
 162
 163         if (smart & (SM_IMM_ELEC))
 164         {
 165                 f4 &= ~(RF4_BR_ELEC);
 166                 f5 &= ~(RF5_BA_ELEC);
 167                 f5 &= ~(RF5_BO_ELEC);
 168         }
 169         else if ((smart & (SM_OPP_ELEC)) && (smart & (SM_RES_ELEC)))
 170         {
 171                 if (int_outof(r_ptr, 80)) f4 &= ~(RF4_BR_ELEC);
 172                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BA_ELEC);
 173                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BO_ELEC);
 174         }
 175         else if ((smart & (SM_OPP_ELEC)) || (smart & (SM_RES_ELEC)))
 176         {
 177                 if (int_outof(r_ptr, 30)) f4 &= ~(RF4_BR_ELEC);
 178                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BA_ELEC);
 179                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BO_ELEC);
 180         }
 181
 182
 183         if (smart & (SM_IMM_FIRE))
 184         {
 185                 f4 &= ~(RF4_BR_FIRE);
 186                 f5 &= ~(RF5_BA_FIRE);
 187                 f5 &= ~(RF5_BO_FIRE);
 188         }
 189         else if ((smart & (SM_OPP_FIRE)) && (smart & (SM_RES_FIRE)))
 190         {
 191                 if (int_outof(r_ptr, 80)) f4 &= ~(RF4_BR_FIRE);
 192                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BA_FIRE);
 193                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BO_FIRE);
 194         }
 195         else if ((smart & (SM_OPP_FIRE)) || (smart & (SM_RES_FIRE)))
 196         {
 197                 if (int_outof(r_ptr, 30)) f4 &= ~(RF4_BR_FIRE);
 198                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BA_FIRE);
 199                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BO_FIRE);
 200         }
 201
 202
 203         if (smart & (SM_IMM_COLD))
 204         {
 205                 f4 &= ~(RF4_BR_COLD);
 206                 f5 &= ~(RF5_BA_COLD);
 207                 f5 &= ~(RF5_BO_COLD);
 208                 f5 &= ~(RF5_BO_ICEE);
 209         }
 210         else if ((smart & (SM_OPP_COLD)) && (smart & (SM_RES_COLD)))
 211         {
 212                 if (int_outof(r_ptr, 80)) f4 &= ~(RF4_BR_COLD);
 213                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BA_COLD);
 214                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BO_COLD);
 215                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BO_ICEE);
 216         }
 217         else if ((smart & (SM_OPP_COLD)) || (smart & (SM_RES_COLD)))
 218         {
 219                 if (int_outof(r_ptr, 30)) f4 &= ~(RF4_BR_COLD);
 220                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BA_COLD);
 221                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BO_COLD);
 222                 if (int_outof(r_ptr, 20)) f5 &= ~(RF5_BO_ICEE);
 223         }
 224
 225
 226         if ((smart & (SM_OPP_POIS)) && (smart & (SM_RES_POIS)))
 227         {
 228                 if (int_outof(r_ptr, 80)) f4 &= ~(RF4_BR_POIS);
 229                 if (int_outof(r_ptr, 80)) f5 &= ~(RF5_BA_POIS);
 230                 if (int_outof(r_ptr, 60)) f4 &= ~(RF4_BA_NUKE);
 231                 if (int_outof(r_ptr, 60)) f4 &= ~(RF4_BR_NUKE);
 232         }
 233         else if ((smart & (SM_OPP_POIS)) || (smart & (SM_RES_POIS)))
 234         {
 235                 if (int_outof(r_ptr, 30)) f4 &= ~(RF4_BR_POIS);
 236                 if (int_outof(r_ptr, 30)) f5 &= ~(RF5_BA_POIS);
 237         }
 238
 239
 240         if (smart & (SM_RES_NETH))
 241         {
 242                 if (prace_is_(RACE_SPECTRE))
 243                 {
 244                         f4 &= ~(RF4_BR_NETH);
 245                         f5 &= ~(RF5_BA_NETH);
 246                         f5 &= ~(RF5_BO_NETH);
 247                 }
 248                 else
 249                 {
 250                         if (int_outof(r_ptr, 20)) f4 &= ~(RF4_BR_NETH);
 251                         if (int_outof(r_ptr, 50)) f5 &= ~(RF5_BA_NETH);
 252                         if (int_outof(r_ptr, 50)) f5 &= ~(RF5_BO_NETH);
 253                 }
 254         }
 255
 256         if (smart & (SM_RES_LITE))
 257         {
 258                 if (int_outof(r_ptr, 50)) f4 &= ~(RF4_BR_LITE);
 259                 if (int_outof(r_ptr, 50)) f5 &= ~(RF5_BA_LITE);
 260         }
 261
 262         if (smart & (SM_RES_DARK))
 263         {
 264                 if (prace_is_(RACE_VAMPIRE))
 265                 {
 266                         f4 &= ~(RF4_BR_DARK);
 267                         f5 &= ~(RF5_BA_DARK);
 268                 }
 269                 else
 270                 {
 271                         if (int_outof(r_ptr, 50)) f4 &= ~(RF4_BR_DARK);
 272                         if (int_outof(r_ptr, 50)) f5 &= ~(RF5_BA_DARK);
 273                 }
 274         }
 275
 276         if (smart & (SM_RES_FEAR))
 277         {
 278                 f5 &= ~(RF5_SCARE);
 279         }
 280
 281         if (smart & (SM_RES_CONF))
 282         {
 283                 f5 &= ~(RF5_CONF);
 284                 if (int_outof(r_ptr, 50)) f4 &= ~(RF4_BR_CONF);
 285         }
 286
 287         if (smart & (SM_RES_CHAOS))
 288         {
 289                 if (int_outof(r_ptr, 20)) f4 &= ~(RF4_BR_CHAO);
 290                 if (int_outof(r_ptr, 50)) f4 &= ~(RF4_BA_CHAO);
 291         }
 292
 293         if (smart & (SM_RES_DISEN))
 294         {
 295                 if (int_outof(r_ptr, 40)) f4 &= ~(RF4_BR_DISE);
 296         }
 297
 298         if (smart & (SM_RES_BLIND))
 299         {
 300                 f5 &= ~(RF5_BLIND);
 301         }
 302
 303         if (smart & (SM_RES_NEXUS))
 304         {
 305                 if (int_outof(r_ptr, 50)) f4 &= ~(RF4_BR_NEXU);
 306                 f6 &= ~(RF6_TELE_LEVEL);
 307         }
 308
 309         if (smart & (SM_RES_SOUND))
 310         {
 311                 if (int_outof(r_ptr, 50)) f4 &= ~(RF4_BR_SOUN);
 312         }
 313
 314         if (smart & (SM_RES_SHARD))
 315         {
 316                 if (int_outof(r_ptr, 40)) f4 &= ~(RF4_BR_SHAR);
 317         }
 318
 319         if (smart & (SM_IMM_REFLECT))
 320         {
 321                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_COLD);
 322                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_FIRE);
 323                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_ACID);
 324                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_ELEC);
 325                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_NETH);
 326                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_WATE);
 327                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_MANA);
 328                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_PLAS);
 329                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_BO_ICEE);
 330                 if (int_outof(r_ptr, 150)) f5 &= ~(RF5_MISSILE);
 331                 if (int_outof(r_ptr, 150)) f4 &= ~(RF4_SHOOT);
 332         }
 333
 334         if (smart & (SM_IMM_FREE))
 335         {
 336                 f5 &= ~(RF5_HOLD);
 337                 f5 &= ~(RF5_SLOW);
 338         }
 339
 340         if (smart & (SM_IMM_MANA))
 341         {
 342                 f5 &= ~(RF5_DRAIN_MANA);
 343         }
 344
 345         /* XXX XXX XXX No spells left? */
 346         /* if (!f4 && !f5 && !f6) ... */
 347
 348         (*f4p) = f4;
 349         (*f5p) = f5;
 350         (*f6p) = f6;
 351 }
 352
 353 #endif /* DRS_SMART_OPTIONS */
 354
 355
 356 /*
 357  * Determine if there is a space near the player in which
 358  * a summoned creature can appear
 359  */
 360 bool summon_possible(int y1, int x1)
 361 {
 362         int y, x;
 363
 364         /* Start at the player's location, and check 2 grids in each dir */
 365         for (y = y1 - 2; y <= y1 + 2; y++)
 366         {
 367                 for (x = x1 - 2; x <= x1 + 2; x++)
 368                 {
 369                         /* Ignore illegal locations */
 370                         if (!in_bounds(y, x)) continue;
 371
 372                         /* Only check a circular area */
 373                         if (distance(y1, x1, y, x)>2) continue;
 374
 375 #if 0
 376                         /* Hack: no summon on glyph of warding */
 377                         if (cave[y][x].feat == FEAT_GLYPH) continue;
 378                         if (cave[y][x].feat == FEAT_MINOR_GLYPH) continue;
 379 #endif
 380
 381                         /* ...nor on the Pattern */
 382                         if ((cave[y][x].feat >= FEAT_PATTERN_START)
 383                                 && (cave[y][x].feat <= FEAT_PATTERN_XTRA2)) continue;
 384
 385                         /* Require empty floor grid in line of sight */
 386                         if ((cave_empty_bold(y, x) || (cave[y][x].feat == FEAT_TREES)) && los(y1, x1, y, x) && los(y, x, y1, x1)) return (TRUE);
 387                 }
 388         }
 389
 390         return FALSE;
 391 }
 392
 393
 394 static bool raise_possible(int y, int x)
 395 {
 396         int xx, yy;
 397         s16b this_o_idx, next_o_idx = 0;
 398         cave_type *c_ptr;
 399
 400         for (xx = x - 5; xx <= x + 5; xx++)
 401         {
 402                 for (yy = y - 5; yy <= y + 5; yy++)
 403                 {
 404                         if (distance(y, x, yy, xx) > 5) continue;
 405                         if (!los(y, x, yy, xx)) continue;
 406
 407                         c_ptr = &cave[yy][xx];
 408                         /* Scan the pile of objects */
 409                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 410                         {
 411                                 /* Acquire object */
 412                                 object_type *o_ptr = &o_list[this_o_idx];
 413
 414                                 /* Acquire next object */
 415                                 next_o_idx = o_ptr->next_o_idx;
 416
 417                                 /* Known to be worthless? */
 418                                 if (o_ptr->tval == TV_CORPSE)
 419                                         return TRUE;
 420                         }
 421                 }
 422         }
 423         return FALSE;
 424 }
 425
 426
 427 /*
 428  * Originally, it was possible for a friendly to shoot another friendly.
 429  * Change it so a "clean shot" means no equally friendly monster is
 430  * between the attacker and target.
 431  */
 432 /*
 433  * Determine if a bolt spell will hit the player.
 434  *
 435  * This is exactly like "projectable", but it will
 436  * return FALSE if a monster is in the way.
 437  * no equally friendly monster is
 438  * between the attacker and target.
 439  */
 440 bool clean_shot(int y1, int x1, int y2, int x2, bool friend)
 441 {
 442         /* Must be the same as projectable() */
 443
 444         int i, y, x;
 445
 446         int grid_n = 0;
 447         u16b grid_g[512];
 448
 449         /* Check the projection path */
 450         grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, 0);
 451
 452         /* No grid is ever projectable from itself */
 453         if (!grid_n) return (FALSE);
 454
 455         /* Final grid */
 456         y = GRID_Y(grid_g[grid_n-1]);
 457         x = GRID_X(grid_g[grid_n-1]);
 458
 459         /* May not end in an unrequested grid */
 460         if ((y != y2) || (x != x2)) return (FALSE);
 461
 462         for (i = 0; i < grid_n; i++)
 463         {
 464                 y = GRID_Y(grid_g[i]);
 465                 x = GRID_X(grid_g[i]);
 466
 467                 if ((cave[y][x].m_idx > 0) && !((y == y2) && (x == x2)))
 468                 {
 469                         monster_type *m_ptr = &m_list[cave[y][x].m_idx];
 470                         if (friend == is_pet(m_ptr))
 471                         {
 472                                 return (FALSE);
 473                         }
 474                 }
 475                 /* Pets may not shoot through the character - TNB */
 476                 if ((y == py) && (x == px))
 477                 {
 478                         if (friend) return (FALSE);
 479                 }
 480         }
 481
 482         return (TRUE);
 483 }
 484
 485 /*
 486  * Cast a bolt at the player
 487  * Stop if we hit a monster
 488  * Affect monsters and the player
 489  */
 490 static void bolt(int m_idx, int typ, int dam_hp, int monspell, bool learnable)
 491 {
 492         int flg = PROJECT_STOP | PROJECT_KILL | PROJECT_PLAYER;
 493
 494         /* Target the player with a bolt attack */
 495         (void)project(m_idx, 0, py, px, dam_hp, typ, flg, (learnable ? monspell : -1));
 496 }
 497
 498 static void beam(int m_idx, int typ, int dam_hp, int monspell, bool learnable)
 499 {
 500         int flg = PROJECT_BEAM | PROJECT_KILL | PROJECT_THRU | PROJECT_PLAYER | PROJECT_NO_REF;
 501
 502         /* Target the player with a bolt attack */
 503         (void)project(m_idx, 0, py, px, dam_hp, typ, flg, (learnable ? monspell : -1));
 504 }
 505
 506
 507 /*
 508  * Cast a breath (or ball) attack at the player
 509  * Pass over any monsters that may be in the way
 510  * Affect grids, objects, monsters, and the player
 511  */
 512 static void breath(int y, int x, int m_idx, int typ, int dam_hp, int rad, bool breath, int monspell, bool learnable)
 513 {
 514         int flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_PLAYER;
 515
 516         monster_type *m_ptr = &m_list[m_idx];
 517         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 518
 519         /* Determine the radius of the blast */
 520         if ((rad < 1) && breath) rad = (r_ptr->flags2 & (RF2_POWERFUL)) ? 3 : 2;
 521
 522         /* Handle breath attacks */
 523         if (breath) rad = 0 - rad;
 524
 525         if (typ == GF_ROCKET) flg |= PROJECT_STOP;
 526
 527         /* Target the player with a ball attack */
 528         (void)project(m_idx, rad, y, x, dam_hp, typ, flg, (learnable ? monspell : -1));
 529 }
 530
 531
 532 u32b get_curse(int power, object_type *o_ptr)
 533 {
 534         u32b new_curse;
 535
 536         while(1)
 537         {
 538                 new_curse = (1 << (randint0(MAX_CURSE)+4));
 539                 if (power == 2)
 540                 {
 541                         if (!(new_curse & TRC_HEAVY_MASK)) continue;
 542                 }
 543                 else if (power == 1)
 544                 {
 545                         if (new_curse & TRC_SPECIAL_MASK) continue;
 546                 }
 547                 else if (power == 0)
 548                 {
 549                         if (new_curse & TRC_HEAVY_MASK) continue;
 550                 }
 551                 if (((o_ptr->tval < TV_BOW) || (o_ptr->tval > TV_SWORD)) && (new_curse == TRC_LOW_MELEE)) continue;
 552                 if (((o_ptr->tval < TV_BOOTS) || (o_ptr->tval > TV_DRAG_ARMOR)) && (new_curse == TRC_LOW_AC)) continue;
 553                 break;
 554         }
 555         return new_curse;
 556 }
 557
 558 void curse_equipment(int chance, int heavy_chance)
 559 {
 560         bool        changed = FALSE;
 561         int         curse_power = 0;
 562         u32b        new_curse;
 563         u32b        o1, o2, o3;
 564         object_type *o_ptr = &inventory[INVEN_RARM + randint0(12)];
 565         char o_name[MAX_NLEN];
 566
 567         if (randint1(100) > chance) return;
 568
 569         if (!o_ptr->k_idx) return;
 570
 571         object_flags(o_ptr, &o1, &o2, &o3);
 572
 573         object_desc(o_name, o_ptr, FALSE, 0);
 574
 575         /* Extra, biased saving throw for blessed items */
 576         if ((o3 & TR3_BLESSED) && (randint1(888) > chance))
 577         {
 578 #ifdef JP
 579 msg_format("%s¤Ï¼ö¤¤¤òÄ·¤ÍÊÖ¤·¤¿¡ª", o_name,
 580 #else
 581                 msg_format("Your %s resist%s cursing!", o_name,
 582 #endif
 583
 584                         ((o_ptr->number > 1) ? "" : "s"));
 585                 /* Hmmm -- can we wear multiple items? If not, this is unnecessary */
 586                 return;
 587         }
 588
 589         if ((randint1(100) <= heavy_chance) &&
 590                 (o_ptr->name1 || o_ptr->name2 || o_ptr->art_name))
 591         {
 592                 if (!(o_ptr->curse_flags & TRC_HEAVY_CURSE))
 593                         changed = TRUE;
 594                 o_ptr->curse_flags |= TRC_HEAVY_CURSE;
 595                 o_ptr->curse_flags |= TRC_CURSED;
 596                 curse_power++;
 597         }
 598         else
 599         {
 600                 if (!cursed_p(o_ptr))
 601                         changed = TRUE;
 602                 o_ptr->curse_flags |= TRC_CURSED;
 603         }
 604         if (heavy_chance >= 50) curse_power++;
 605
 606         new_curse = get_curse(curse_power, o_ptr);
 607         if (!(o_ptr->curse_flags & new_curse))
 608         {
 609                 changed = TRUE;
 610                 o_ptr->curse_flags |= new_curse;
 611         }
 612
 613         if (changed)
 614         {
 615 #ifdef JP
 616 msg_format("°°Õ¤ËËþ¤Á¤¿¹õ¤¤¥ª¡¼¥é¤¬%s¤ò¤È¤ê¤Þ¤¤¤¿...", o_name);
 617 #else
 618                 msg_format("There is a malignant black aura surrounding %s...", o_name);
 619 #endif
 620
 621                 o_ptr->feeling = FEEL_NONE;
 622         }
 623         p_ptr->update |= (PU_BONUS);
 624 }
 625
 626
 627 /*
 628  * Return TRUE if a spell is good for hurting the player (directly).
 629  */
 630 static bool spell_attack(byte spell)
 631 {
 632         /* All RF4 spells hurt (except for shriek and dispel) */
 633         if (spell < 128 && spell > 98) return (TRUE);
 634
 635         /* Various "ball" spells */
 636         if (spell >= 128 && spell <= 128 + 8) return (TRUE);
 637
 638         /* "Cause wounds" and "bolt" spells */
 639         if (spell >= 128 + 12 && spell < 128 + 27) return (TRUE);
 640
 641         /* Hand of Doom */
 642         if (spell == 160 + 1) return (TRUE);
 643
 644         /* Psycho-Spear */
 645         if (spell == 160 + 11) return (TRUE);
 646
 647         /* Doesn't hurt */
 648         return (FALSE);
 649 }
 650
 651
 652 /*
 653  * Return TRUE if a spell is good for escaping.
 654  */
 655 static bool spell_escape(byte spell)
 656 {
 657         /* Blink or Teleport */
 658         if (spell == 160 + 4 || spell == 160 + 5) return (TRUE);
 659
 660         /* Teleport the player away */
 661         if (spell == 160 + 9 || spell == 160 + 10) return (TRUE);
 662
 663         /* Isn't good for escaping */
 664         return (FALSE);
 665 }
 666
 667 /*
 668  * Return TRUE if a spell is good for annoying the player.
 669  */
 670 static bool spell_annoy(byte spell)
 671 {
 672         /* Shriek */
 673         if (spell == 96 + 0) return (TRUE);
 674
 675         /* Brain smash, et al (added curses) */
 676         if (spell >= 128 + 9 && spell <= 128 + 14) return (TRUE);
 677
 678         /* Scare, confuse, blind, slow, paralyze */
 679         if (spell >= 128 + 27 && spell <= 128 + 31) return (TRUE);
 680
 681         /* Teleport to */
 682         if (spell == 160 + 8) return (TRUE);
 683
 684         /* Teleport level */
 685         if (spell == 160 + 10) return (TRUE);
 686
 687         /* Darkness, make traps, cause amnesia */
 688         if (spell >= 160 + 12 && spell <= 160 + 14) return (TRUE);
 689
 690         /* Doesn't annoy */
 691         return (FALSE);
 692 }
 693
 694 /*
 695  * Return TRUE if a spell summons help.
 696  */
 697 static bool spell_summon(byte spell)
 698 {
 699         /* All summon spells */
 700         if (spell >= 160 + 16) return (TRUE);
 701
 702         /* Doesn't summon */
 703         return (FALSE);
 704 }
 705
 706
 707 /*
 708  * Return TRUE if a spell raise-dead.
 709  */
 710 static bool spell_raise(byte spell)
 711 {
 712         /* All raise-dead spells */
 713         if (spell == 160 + 15) return (TRUE);
 714
 715         /* Doesn't summon */
 716         return (FALSE);
 717 }
 718
 719
 720 /*
 721  * Return TRUE if a spell is good in a tactical situation.
 722  */
 723 static bool spell_tactic(byte spell)
 724 {
 725         /* Blink */
 726         if (spell == 160 + 4) return (TRUE);
 727
 728         /* Not good */
 729         return (FALSE);
 730 }
 731
 732 /*
 733  * Return TRUE if a spell makes invulnerable.
 734  */
 735 static bool spell_invulner(byte spell)
 736 {
 737         /* Invulnerability */
 738         if (spell == 160 + 3) return (TRUE);
 739
 740         /* No invulnerability */
 741         return (FALSE);
 742 }
 743
 744 /*
 745  * Return TRUE if a spell hastes.
 746  */
 747 static bool spell_haste(byte spell)
 748 {
 749         /* Haste self */
 750         if (spell == 160 + 0) return (TRUE);
 751
 752         /* Not a haste spell */
 753         return (FALSE);
 754 }
 755
 756
 757 /*
 758  * Return TRUE if a spell world.
 759  */
 760 static bool spell_world(byte spell)
 761 {
 762         /* world */
 763         if (spell == 160 + 6) return (TRUE);
 764
 765         /* Not a haste spell */
 766         return (FALSE);
 767 }
 768
 769
 770 /*
 771  * Return TRUE if a spell special.
 772  */
 773 static bool spell_special(byte spell)
 774 {
 775         if (p_ptr->inside_battle) return FALSE;
 776
 777         /* world */
 778         if (spell == 160 + 7) return (TRUE);
 779
 780         /* Not a haste spell */
 781         return (FALSE);
 782 }
 783
 784
 785 /*
 786  * Return TRUE if a spell psycho-spear.
 787  */
 788 static bool spell_psy_spe(byte spell)
 789 {
 790         /* world */
 791         if (spell == 160 + 11) return (TRUE);
 792
 793         /* Not a haste spell */
 794         return (FALSE);
 795 }
 796
 797
 798 /*
 799  * Return TRUE if a spell is good for healing.
 800  */
 801 static bool spell_heal(byte spell)
 802 {
 803         /* Heal */
 804         if (spell == 160 + 2) return (TRUE);
 805
 806         /* No healing */
 807         return (FALSE);
 808 }
 809
 810
 811 /*
 812  * Return TRUE if a spell is good for dispel.
 813  */
 814 static bool spell_dispel(byte spell)
 815 {
 816         /* Dispel */
 817         if (spell == 96 + 2) return (TRUE);
 818
 819         /* No dispel */
 820         return (FALSE);
 821 }
 822
 823
 824 /*
 825  * Check should monster cast dispel spell.
 826  */
 827 static bool dispel_check(int m_idx)
 828 {
 829         monster_type *m_ptr = &m_list[m_idx];
 830         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 831
 832         /* Invulnabilty */
 833         if (p_ptr->invuln) return (TRUE);
 834
 835         /* Wraith form */
 836         if (p_ptr->wraith_form) return (TRUE);
 837
 838         /* Shield */
 839         if (p_ptr->shield) return (TRUE);
 840
 841         /* Magic defence */
 842         if (p_ptr->magicdef) return (TRUE);
 843
 844         /* Multi Shadow */
 845         if (p_ptr->multishadow) return (TRUE);
 846
 847         /* Robe of dust */
 848         if (p_ptr->dustrobe) return (TRUE);
 849
 850         /* Berserk Strength */
 851         if (p_ptr->shero && (p_ptr->pclass != CLASS_BERSERKER)) return (TRUE);
 852
 853         /* Invulnability song */
 854         if (music_singing(MUSIC_INVULN)) return (TRUE);
 855
 856         /* Demon Lord */
 857         if (p_ptr->mimic_form == MIMIC_DEMON_LORD) return (TRUE);
 858
 859         /* Elemental resistances */
 860         if (r_ptr->flags4 & RF4_BR_ACID)
 861         {
 862                 if (!p_ptr->immune_acid && p_ptr->oppose_acid) return (TRUE);
 863
 864                 if (p_ptr->special_defense & DEFENSE_ACID) return (TRUE);
 865         }
 866
 867         if (r_ptr->flags4 & RF4_BR_FIRE)
 868         {
 869                 if (!((p_ptr->prace == RACE_DEMON) && p_ptr->lev > 44))
 870                 {
 871                         if(!p_ptr->immune_fire && p_ptr->oppose_fire) return (TRUE);
 872
 873                         if(p_ptr->special_defense & DEFENSE_FIRE) return(TRUE);
 874                 }
 875         }
 876
 877         if (r_ptr->flags4 & RF4_BR_ELEC)
 878         {
 879                 if (!p_ptr->immune_elec && p_ptr->oppose_elec) return (TRUE);
 880
 881                 if (p_ptr->special_defense & DEFENSE_ELEC) return (TRUE);
 882         }
 883
 884         if (r_ptr->flags4 & RF4_BR_COLD)
 885         {
 886                 if (!p_ptr->immune_cold && p_ptr->oppose_cold) return (TRUE);
 887
 888                 if (p_ptr->special_defense & DEFENSE_COLD) return (TRUE);
 889         }
 890
 891         if (r_ptr->flags4 & (RF4_BR_POIS | RF4_BR_NUKE))
 892         {
 893                 if (!((p_ptr->pclass == CLASS_NINJA) && p_ptr->lev > 44))
 894                 {
 895                         if (p_ptr->oppose_pois) return (TRUE);
 896
 897                         if (p_ptr->special_defense & DEFENSE_POIS) return (TRUE);
 898                 }
 899         }
 900
 901         /* Elemental resist music */
 902         if (music_singing(MUSIC_RESIST))
 903         {
 904                 if (r_ptr->flags4 & (RF4_BR_ACID | RF4_BR_FIRE | RF4_BR_ELEC | RF4_BR_COLD | RF4_BR_POIS)) return (TRUE);
 905         }
 906
 907         /* Ultimate resistance */
 908         if (p_ptr->ult_res) return (TRUE);
 909
 910         /* Potion of Neo Tsuyosi special */
 911         if (p_ptr->tsuyoshi) return (TRUE);
 912
 913         /* Elemental Brands */
 914         if ((p_ptr->special_attack & ATTACK_ACID) && !(r_ptr->flags3 & RF3_IM_ACID)) return (TRUE);
 915         if ((p_ptr->special_attack & ATTACK_FIRE) && !(r_ptr->flags3 & RF3_IM_FIRE)) return (TRUE);
 916         if ((p_ptr->special_attack & ATTACK_ELEC) && !(r_ptr->flags3 & RF3_IM_ELEC)) return (TRUE);
 917         if ((p_ptr->special_attack & ATTACK_COLD) && !(r_ptr->flags3 & RF3_IM_COLD)) return (TRUE);
 918         if ((p_ptr->special_attack & ATTACK_POIS) && !(r_ptr->flags3 & RF3_IM_POIS)) return (TRUE);
 919
 920         /* Speed */
 921         if (p_ptr->pspeed < 145)
 922         {
 923                 if (p_ptr->fast) return (TRUE);
 924
 925                 if (music_singing(MUSIC_SPEED)) return (TRUE);
 926
 927                 if (music_singing(MUSIC_SHERO)) return (TRUE);
 928         }
 929
 930         /* Light speed */
 931         if (p_ptr->lightspeed && (m_ptr->mspeed < 136)) return (TRUE);
 932
 933         if (p_ptr->riding && (m_list[p_ptr->riding].mspeed < 135))
 934         {
 935                 if (m_list[p_ptr->riding].fast) return (TRUE);
 936         }
 937
 938         /* No need to cast dispel spell */
 939         return (FALSE);
 940 }
 941
 942
 943 /*
 944  * Have a monster choose a spell from a list of "useful" spells.
 945  *
 946  * Note that this list does NOT include spells that will just hit
 947  * other monsters, and the list is restricted when the monster is
 948  * "desperate".  Should that be the job of this function instead?
 949  *
 950  * Stupid monsters will just pick a spell randomly.  Smart monsters
 951  * will choose more "intelligently".
 952  *
 953  * Use the helper functions above to put spells into categories.
 954  *
 955  * This function may well be an efficiency bottleneck.
 956  */
 957 static int choose_attack_spell(int m_idx, byte spells[], byte num)
 958 {
 959         monster_type *m_ptr = &m_list[m_idx];
 960         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 961
 962         byte escape[96], escape_num = 0;
 963         byte attack[96], attack_num = 0;
 964         byte summon[96], summon_num = 0;
 965         byte tactic[96], tactic_num = 0;
 966         byte annoy[96], annoy_num = 0;
 967         byte invul[96], invul_num = 0;
 968         byte haste[96], haste_num = 0;
 969         byte world[96], world_num = 0;
 970         byte special[96], special_num = 0;
 971         byte psy_spe[96], psy_spe_num = 0;
 972         byte raise[96], raise_num = 0;
 973         byte heal[96], heal_num = 0;
 974         byte dispel[96], dispel_num = 0;
 975
 976         int i;
 977
 978         /* Stupid monsters choose randomly */
 979         if (r_ptr->flags2 & (RF2_STUPID))
 980         {
 981                 /* Pick at random */
 982                 return (spells[randint0(num)]);
 983         }
 984
 985         /* Categorize spells */
 986         for (i = 0; i < num; i++)
 987         {
 988                 /* Escape spell? */
 989                 if (spell_escape(spells[i])) escape[escape_num++] = spells[i];
 990
 991                 /* Attack spell? */
 992                 if (spell_attack(spells[i])) attack[attack_num++] = spells[i];
 993
 994                 /* Summon spell? */
 995                 if (spell_summon(spells[i])) summon[summon_num++] = spells[i];
 996
 997                 /* Tactical spell? */
 998                 if (spell_tactic(spells[i])) tactic[tactic_num++] = spells[i];
 999
1000                 /* Annoyance spell? */
1001                 if (spell_annoy(spells[i])) annoy[annoy_num++] = spells[i];
1002
1003                 /* Invulnerability spell? */
1004                 if (spell_invulner(spells[i])) invul[invul_num++] = spells[i];
1005
1006                 /* Haste spell? */
1007                 if (spell_haste(spells[i])) haste[haste_num++] = spells[i];
1008
1009                 /* World spell? */
1010                 if (spell_world(spells[i])) world[world_num++] = spells[i];
1011
1012                 /* Special spell? */
1013                 if (spell_special(spells[i])) special[special_num++] = spells[i];
1014
1015                 /* Psycho-spear spell? */
1016                 if (spell_psy_spe(spells[i])) psy_spe[psy_spe_num++] = spells[i];
1017
1018                 /* Raise-dead spell? */
1019                 if (spell_raise(spells[i])) raise[raise_num++] = spells[i];
1020
1021                 /* Heal spell? */
1022                 if (spell_heal(spells[i])) heal[heal_num++] = spells[i];
1023
1024                 /* Dispel spell? */
1025                 if (spell_dispel(spells[i])) dispel[dispel_num++] = spells[i];
1026         }
1027
1028         /*** Try to pick an appropriate spell type ***/
1029
1030         /* world */
1031         if (world_num && (randint0(100) < 15) && !world_monster)
1032         {
1033                 /* Choose haste spell */
1034                 return (world[randint0(world_num)]);
1035         }
1036
1037         /* special */
1038         if (special_num)
1039         {
1040                 bool success = FALSE;
1041                 switch(m_ptr->r_idx)
1042                 {
1043                         case MON_BANOR:
1044                         case MON_LUPART:
1045                                 if ((m_ptr->hp < m_ptr->maxhp / 2) && r_info[MON_BANOR].max_num && r_info[MON_LUPART].max_num) success = TRUE;
1046                                 break;
1047                         default: break;
1048                 }
1049                 if (success) return (special[randint0(special_num)]);
1050         }
1051
1052         /* Still hurt badly, couldn't flee, attempt to heal */
1053         if (m_ptr->hp < m_ptr->maxhp / 3 && one_in_(2))
1054         {
1055                 /* Choose heal spell if possible */
1056                 if (heal_num) return (heal[randint0(heal_num)]);
1057         }
1058
1059         /* Hurt badly or afraid, attempt to flee */
1060         if (((m_ptr->hp < m_ptr->maxhp / 3) || m_ptr->monfear) && one_in_(2))
1061         {
1062                 /* Choose escape spell if possible */
1063                 if (escape_num) return (escape[randint0(escape_num)]);
1064         }
1065
1066         /* special */
1067         if (special_num)
1068         {
1069                 bool success = FALSE;
1070                 switch(m_ptr->r_idx)
1071                 {
1072                         case MON_OHMU:
1073                                 if (randint0(100) < 50) success = TRUE;
1074                                 break;
1075                         case MON_BANORLUPART:
1076                                 if (randint0(100) < 70) success = TRUE;
1077                                 break;
1078                         default: break;
1079                 }
1080                 if (success) return (special[randint0(special_num)]);
1081         }
1082
1083         /* Player is close and we have attack spells, blink away */
1084         if ((distance(py, px, m_ptr->fy, m_ptr->fx) < 4) && (attack_num || (r_ptr->flags6 & RF6_TRAPS)) && (randint0(100) < 75) && !world_monster)
1085         {
1086                 /* Choose tactical spell */
1087                 if (tactic_num) return (tactic[randint0(tactic_num)]);
1088         }
1089
1090         /* Summon if possible (sometimes) */
1091         if (summon_num && (randint0(100) < 40))
1092         {
1093                 /* Choose summon spell */
1094                 return (summon[randint0(summon_num)]);
1095         }
1096
1097         /* dispel */
1098         if (dispel_num && one_in_(2))
1099         {
1100                 /* Choose dispel spell if possible */
1101                 if (dispel_check(m_idx))
1102                 {
1103                         return (dispel[randint0(dispel_num)]);
1104                 }
1105         }
1106
1107         /* Raise-dead if possible (sometimes) */
1108         if (raise_num && (randint0(100) < 40) && raise_possible(m_ptr->fy, m_ptr->fx))
1109         {
1110                 /* Choose raise-dead spell */
1111                 return (raise[randint0(raise_num)]);
1112         }
1113
1114         /* Attack spell (most of the time) */
1115         if (p_ptr->invuln)
1116         {
1117                 if (psy_spe_num && (randint0(100) < 50))
1118                 {
1119                         /* Choose attack spell */
1120                         return (psy_spe[randint0(psy_spe_num)]);
1121                 }
1122                 else if (attack_num && (randint0(100) < 40))
1123                 {
1124                         /* Choose attack spell */
1125                         return (attack[randint0(attack_num)]);
1126                 }
1127         }
1128         else if (attack_num && (randint0(100) < 85))
1129         {
1130                 /* Choose attack spell */
1131                 return (attack[randint0(attack_num)]);
1132         }
1133
1134         /* Try another tactical spell (sometimes) */
1135         if (tactic_num && (randint0(100) < 50) && !world_monster)
1136         {
1137                 /* Choose tactic spell */
1138                 return (tactic[randint0(tactic_num)]);
1139         }
1140
1141         /* Cast globe of invulnerability if not already in effect */
1142         if (invul_num && !(m_ptr->invulner) && (randint0(100) < 50))
1143         {
1144                 /* Choose Globe of Invulnerability */
1145                 return (invul[randint0(invul_num)]);
1146         }
1147
1148         /* We're hurt (not badly), try to heal */
1149         if ((m_ptr->hp < m_ptr->maxhp * 3 / 4) && (randint0(100) < 25))
1150         {
1151                 /* Choose heal spell if possible */
1152                 if (heal_num) return (heal[randint0(heal_num)]);
1153         }
1154
1155         /* Haste self if we aren't already somewhat hasted (rarely) */
1156         if (haste_num && (randint0(100) < 20) && !(m_ptr->fast))
1157         {
1158                 /* Choose haste spell */
1159                 return (haste[randint0(haste_num)]);
1160         }
1161
1162         /* Annoy player (most of the time) */
1163         if (annoy_num && (randint0(100) < 80))
1164         {
1165                 /* Choose annoyance spell */
1166                 return (annoy[randint0(annoy_num)]);
1167         }
1168
1169         /* Choose no spell */
1170         return (0);
1171 }
1172
1173
1174 /*
1175  * Creatures can cast spells, shoot missiles, and breathe.
1176  *
1177  * Returns "TRUE" if a spell (or whatever) was (successfully) cast.
1178  *
1179  * XXX XXX XXX This function could use some work, but remember to
1180  * keep it as optimized as possible, while retaining generic code.
1181  *
1182  * Verify the various "blind-ness" checks in the code.
1183  *
1184  * XXX XXX XXX Note that several effects should really not be "seen"
1185  * if the player is blind.  See also "effects.c" for other "mistakes".
1186  *
1187  * Perhaps monsters should breathe at locations *near* the player,
1188  * since this would allow them to inflict "partial" damage.
1189  *
1190  * Perhaps smart monsters should decline to use "bolt" spells if
1191  * there is a monster in the way, unless they wish to kill it.
1192  *
1193  * Note that, to allow the use of the "track_target" option at some
1194  * later time, certain non-optimal things are done in the code below,
1195  * including explicit checks against the "direct" variable, which is
1196  * currently always true by the time it is checked, but which should
1197  * really be set according to an explicit "projectable()" test, and
1198  * the use of generic "x,y" locations instead of the player location,
1199  * with those values being initialized with the player location.
1200  *
1201  * It will not be possible to "correctly" handle the case in which a
1202  * monster attempts to attack a location which is thought to contain
1203  * the player, but which in fact is nowhere near the player, since this
1204  * might induce all sorts of messages about the attack itself, and about
1205  * the effects of the attack, which the player might or might not be in
1206  * a position to observe.  Thus, for simplicity, it is probably best to
1207  * only allow "faulty" attacks by a monster if one of the important grids
1208  * (probably the initial or final grid) is in fact in view of the player.
1209  * It may be necessary to actually prevent spell attacks except when the
1210  * monster actually has line of sight to the player.  Note that a monster
1211  * could be left in a bizarre situation after the player ducked behind a
1212  * pillar and then teleported away, for example.
1213  *
1214  * Note that certain spell attacks do not use the "project()" function
1215  * but "simulate" it via the "direct" variable, which is always at least
1216  * as restrictive as the "project()" function.  This is necessary to
1217  * prevent "blindness" attacks and such from bending around walls, etc,
1218  * and to allow the use of the "track_target" option in the future.
1219  *
1220  * Note that this function attempts to optimize the use of spells for the
1221  * cases in which the monster has no spells, or has spells but cannot use
1222  * them, or has spells but they will have no "useful" effect.  Note that
1223  * this function has been an efficiency bottleneck in the past.
1224  *
1225  * Note the special "MFLAG_NICE" flag, which prevents a monster from using
1226  * any spell attacks until the player has had a single chance to move.
1227  */
1228 bool make_attack_spell(int m_idx)
1229 {
1230         int             k, chance, thrown_spell = 0, rlev, failrate;
1231         byte            spell[96], num = 0;
1232         u32b            f4, f5, f6;
1233         monster_type    *m_ptr = &m_list[m_idx];
1234         monster_race    *r_ptr = &r_info[m_ptr->r_idx];
1235         char            m_name[80];
1236         char            m_poss[80];
1237         char            ddesc[80];
1238         bool            no_inate = FALSE;
1239         bool            do_disi = FALSE;
1240         int             dam = 0;
1241         u32b mode = 0L;
1242         int s_num_6 = (easy_band ? 2 : 6);
1243         int s_num_4 = (easy_band ? 1 : 4);
1244
1245         /* Target location */
1246         int x = px;
1247         int y = py;
1248
1249         /* Summon count */
1250         int count = 0;
1251
1252         /* Extract the blind-ness */
1253         bool blind = (p_ptr->blind ? TRUE : FALSE);
1254
1255         /* Extract the "see-able-ness" */
1256         bool seen = (!blind && m_ptr->ml);
1257
1258         bool maneable = player_has_los_bold(m_ptr->fy, m_ptr->fx);
1259         bool learnable = (seen && maneable && !world_monster);
1260
1261         /* Assume "normal" target */
1262         bool normal = TRUE;
1263
1264         /* Assume "projectable" */
1265         bool direct = TRUE;
1266
1267         /* Cannot cast spells when confused */
1268         if (m_ptr->confused)
1269         {
1270                 reset_target(m_ptr);
1271                 return (FALSE);
1272         }
1273
1274         /* Cannot cast spells when nice */
1275         if (m_ptr->mflag & MFLAG_NICE) return (FALSE);
1276         if (!is_hostile(m_ptr)) return (FALSE);
1277
1278         /* Hack -- Extract the spell probability */
1279         chance = (r_ptr->freq_inate + r_ptr->freq_spell) / 2;
1280
1281         /* Not allowed to cast spells */
1282         if (!chance) return (FALSE);
1283
1284
1285         if (stupid_monsters)
1286         {
1287                 /* Only do spells occasionally */
1288                 if (randint0(100) >= chance) return (FALSE);
1289         }
1290         else
1291         {
1292                 if (randint0(100) >=  chance) return (FALSE);
1293
1294                 /* Sometimes forbid inate attacks (breaths) */
1295                 if (randint0(100) >= (chance * 2)) no_inate = TRUE;
1296         }
1297
1298         /* XXX XXX XXX Handle "track_target" option (?) */
1299
1300
1301         /* Extract the racial spell flags */
1302         f4 = r_ptr->flags4;
1303         f5 = r_ptr->flags5;
1304         f6 = r_ptr->flags6;
1305
1306         /* Hack -- require projectable player */
1307         if (normal)
1308         {
1309                 /* Check range */
1310                 if ((m_ptr->cdis > MAX_RANGE) && !m_ptr->target_y) return (FALSE);
1311
1312                 /* Check path */
1313                 if (projectable(m_ptr->fy, m_ptr->fx, y, x))
1314                 {
1315                         /* Breath disintegration to the glyph */
1316                         if ((!cave_floor_bold(y,x)) && (r_ptr->flags4 & RF4_BR_DISI) && one_in_(2)) do_disi = TRUE;
1317                 }
1318
1319                 /* Check path to next grid */
1320                 else
1321                 {
1322                         bool success = FALSE;
1323
1324                         if ((r_ptr->flags4 & RF4_BR_DISI) &&
1325                             (m_ptr->cdis < MAX_RANGE/2) &&
1326                             in_disintegration_range(m_ptr->fy, m_ptr->fx, y, x) &&
1327                             (one_in_(10) || (projectable(y, x, m_ptr->fy, m_ptr->fx) && one_in_(2))))
1328                         {
1329                                 do_disi = TRUE;
1330                                 success = TRUE;
1331                         }
1332                         else
1333                         {
1334                                 int i;
1335                                 int tonari;
1336                                 int tonari_y[4][8] = {{-1,-1,-1,0,0,1,1,1},
1337                                                       {-1,-1,-1,0,0,1,1,1},
1338                                                       {1,1,1,0,0,-1,-1,-1},
1339                                                       {1,1,1,0,0,-1,-1,-1}};
1340                                 int tonari_x[4][8] = {{-1,0,1,-1,1,-1,0,1},
1341                                                       {1,0,-1,1,-1,1,0,-1},
1342                                                       {-1,0,1,-1,1,-1,0,1},
1343                                                       {1,0,-1,1,-1,1,0,-1}};
1344
1345                                 if (m_ptr->fy < py && m_ptr->fx < px) tonari = 0;
1346                                 else if (m_ptr->fy < py) tonari = 1;
1347                                 else if (m_ptr->fx < px) tonari = 2;
1348                                 else tonari = 3;
1349
1350                                 for (i = 0; i < 8; i++)
1351                                 {
1352                                         int next_x = x + tonari_x[tonari][i];
1353                                         int next_y = y + tonari_y[tonari][i];
1354                                         cave_type *c_ptr;
1355
1356                                         /* Access the next grid */
1357                                         c_ptr = &cave[next_y][next_x];
1358
1359                                         /* Skip door, rubble, wall */
1360                                         if ((c_ptr->feat >= FEAT_DOOR_HEAD) && (c_ptr->feat <= FEAT_PERM_SOLID)) continue;
1361
1362                                         /* Skip tree */
1363                                         if (c_ptr->feat == FEAT_TREES) continue;
1364
1365                                         /* Skip mountain */
1366                                         if (c_ptr->feat == FEAT_MOUNTAIN) continue;
1367
1368                                         if (projectable(m_ptr->fy, m_ptr->fx, next_y, next_x))
1369                                         {
1370                                                 y = next_y;
1371                                                 x = next_x;
1372                                                 success = TRUE;
1373                                                 break;
1374                                         }
1375                                 }
1376                         }
1377
1378                         if (!success)
1379                         {
1380                                 if (m_ptr->target_y && m_ptr->target_x)
1381                                 {
1382                                         y = m_ptr->target_y;
1383                                         x = m_ptr->target_x;
1384                                         f4 &= (RF4_INDIRECT_MASK);
1385                                         f5 &= (RF5_INDIRECT_MASK);
1386                                         f6 &= (RF6_INDIRECT_MASK);
1387                                         success = TRUE;
1388                                 }
1389                         }
1390
1391                         /* No spells */
1392                         if (!success) return FALSE;
1393                 }
1394         }
1395
1396         reset_target(m_ptr);
1397
1398         /* Extract the monster level */
1399         rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
1400
1401         if (!stupid_monsters)
1402         {
1403                 /* Forbid inate attacks sometimes */
1404                 if (no_inate) f4 &= 0x500000FF;
1405         }
1406
1407         if (!p_ptr->csp)
1408         {
1409                 f5 &= ~(RF5_DRAIN_MANA);
1410         }
1411         if ((p_ptr->pclass == CLASS_NINJA) && (r_ptr->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)))
1412         {
1413                 f6 &= ~(RF6_DARKNESS);
1414         }
1415
1416         if (dun_level && (!p_ptr->inside_quest || (p_ptr->inside_quest < MIN_RANDOM_QUEST)) && (d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
1417         {
1418                 f4 &= (RF4_NOMAGIC_MASK);
1419                 f5 &= (RF5_NOMAGIC_MASK);
1420                 f6 &= (RF6_NOMAGIC_MASK);
1421         }
1422
1423         /* Hack -- allow "desperate" spells */
1424         if ((r_ptr->flags2 & (RF2_SMART)) &&
1425                 (m_ptr->hp < m_ptr->maxhp / 10) &&
1426                 (randint0(100) < 50))
1427         {
1428                 /* Require intelligent spells */
1429                 f4 &= (RF4_INT_MASK);
1430                 f5 &= (RF5_INT_MASK);
1431                 f6 &= (RF6_INT_MASK);
1432
1433                 /* No spells left */
1434                 if (!f4 && !f5 && !f6) return (FALSE);
1435         }
1436
1437         /* Remove the "ineffective" spells */
1438         remove_bad_spells(m_idx, &f4, &f5, &f6);
1439
1440         if (p_ptr->inside_arena)
1441         {
1442                 f4 &= ~(RF4_SUMMON_MASK);
1443                 f5 &= ~(RF5_SUMMON_MASK);
1444                 f6 &= ~(RF6_SUMMON_MASK);
1445         }
1446
1447         /* No spells left */
1448         if (!f4 && !f5 && !f6) return (FALSE);
1449
1450         if (!stupid_monsters)
1451         {
1452                 /* Check for a clean bolt shot */
1453                 if (((f4 & RF4_BOLT_MASK) ||
1454                      (f5 & RF5_BOLT_MASK) ||
1455                      (f6 & RF6_BOLT_MASK)) &&
1456                      !(r_ptr->flags2 & RF2_STUPID) &&
1457                      !clean_shot(m_ptr->fy, m_ptr->fx, py, px, FALSE))
1458                 {
1459                         /* Remove spells that will only hurt friends */
1460                         f4 &= ~(RF4_BOLT_MASK);
1461                         f5 &= ~(RF5_BOLT_MASK);
1462                         f6 &= ~(RF6_BOLT_MASK);
1463                 }
1464
1465                 /* Check for a possible summon */
1466                 if (((f4 & RF4_SUMMON_MASK) ||
1467                      (f5 & RF5_SUMMON_MASK) ||
1468                      (f6 & RF6_SUMMON_MASK)) &&
1469                      !(r_ptr->flags2 & RF2_STUPID) &&
1470                      !(summon_possible(y, x)))
1471                 {
1472                         /* Remove summoning spells */
1473                         f4 &= ~(RF4_SUMMON_MASK);
1474                         f5 &= ~(RF5_SUMMON_MASK);
1475                         f6 &= ~(RF6_SUMMON_MASK);
1476                 }
1477
1478                 /* No spells left */
1479                 if (!f4 && !f5 && !f6) return (FALSE);
1480         }
1481
1482         /* Extract the "inate" spells */
1483         for (k = 0; k < 32; k++)
1484         {
1485                 if (f4 & (1L << k)) spell[num++] = k + 32 * 3;
1486         }
1487
1488         /* Extract the "normal" spells */
1489         for (k = 0; k < 32; k++)
1490         {
1491                 if (f5 & (1L << k)) spell[num++] = k + 32 * 4;
1492         }
1493
1494         /* Extract the "bizarre" spells */
1495         for (k = 0; k < 32; k++)
1496         {
1497                 if (f6 & (1L << k)) spell[num++] = k + 32 * 5;
1498         }
1499
1500         /* No spells left */
1501         if (!num) return (FALSE);
1502
1503         /* Stop if player is dead or gone */
1504         if (!p_ptr->playing || p_ptr->is_dead) return (FALSE);
1505
1506         /* Stop if player is leaving */
1507         if (p_ptr->leaving) return (FALSE);
1508
1509         /* Get the monster name (or "it") */
1510         monster_desc(m_name, m_ptr, 0x00);
1511
1512         /* Get the monster possessive ("his"/"her"/"its") */
1513         monster_desc(m_poss, m_ptr, 0x22);
1514
1515         /* Hack -- Get the "died from" name */
1516         monster_desc(ddesc, m_ptr, 0x288);
1517
1518         if (stupid_monsters)
1519         {
1520                 /* Choose a spell to cast */
1521                 thrown_spell = spell[randint0(num)];
1522         }
1523         else
1524         {
1525                 int attempt = 10;
1526                 if (do_disi) thrown_spell = 96+31;
1527                 else
1528                 {
1529                         while(attempt--)
1530                         {
1531                                 thrown_spell = choose_attack_spell(m_idx, spell, num);
1532                                 if (thrown_spell) break;
1533                         }
1534                 }
1535
1536                 /* Abort if no spell was chosen */
1537                 if (!thrown_spell) return (FALSE);
1538
1539                 /* Calculate spell failure rate */
1540                 failrate = 25 - (rlev + 3) / 4;
1541
1542                 /* Hack -- Stupid monsters will never fail (for jellies and such) */
1543                 if (r_ptr->flags2 & RF2_STUPID) failrate = 0;
1544
1545                 /* Check for spell failure (inate attacks never fail) */
1546                 if ((thrown_spell >= 128) && ((m_ptr->stunned && one_in_(2)) || (randint0(100) < failrate)))
1547                 {
1548                         disturb(1, 0);
1549                         /* Message */
1550                         if (thrown_spell != (160+7)) /* Not RF6_SPECIAL */
1551                         {
1552 #ifdef JP
1553 msg_format("%^s¤Ï¼öÊ¸¤ò¾§¤¨¤è¤¦¤È¤·¤¿¤¬¼ºÇÔ¤·¤¿¡£", m_name);
1554 #else
1555                                 msg_format("%^s tries to cast a spell, but fails.", m_name);
1556 #endif
1557                         }
1558
1559                         return (TRUE);
1560                 }
1561         }
1562
1563
1564         /* Cast the spell. */
1565         switch (thrown_spell)
1566         {
1567                 /* RF4_SHRIEK */
1568                 case 96+0:
1569                 {
1570                         if (!direct) break;
1571                         disturb(1, 0);
1572 #ifdef JP
1573 msg_format("%^s¤¬¤«¤ó¹â¤¤¶âÀÚ¤êÀ¼¤ò¤¢¤²¤¿¡£", m_name);
1574 #else
1575                         msg_format("%^s makes a high pitched shriek.", m_name);
1576 #endif
1577
1578                         aggravate_monsters(m_idx);
1579                         break;
1580                 }
1581
1582                 /* RF4_XXX1 */
1583                 case 96+1:
1584                 {
1585                         /* XXX XXX XXX */
1586                         break;
1587                 }
1588
1589                 /* RF4_DISPEL */
1590                 case 96+2:
1591                 {
1592                         if (x!=px || y!=py) return (FALSE);
1593                         disturb(1, 0);
1594 #ifdef JP
1595                         if (blind) msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1596                         else msg_format("%^s¤¬ËâÎÏ¾Ãµî¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name);
1597 #else
1598                         if (blind) msg_format("%^s mumbles powerfully.", m_name);
1599                         else msg_format("%^s invokes a dispel magic.", m_name);
1600 #endif
1601                         set_fast(0, TRUE);
1602                         set_lightspeed(0, TRUE);
1603                         set_slow(0, TRUE);
1604                         set_shield(0, TRUE);
1605                         set_blessed(0, TRUE);
1606                         set_tsuyoshi(0, TRUE);
1607                         set_hero(0, TRUE);
1608                         set_shero(0, TRUE);
1609                         set_protevil(0, TRUE);
1610                         set_invuln(0, TRUE);
1611                         set_wraith_form(0, TRUE);
1612                         set_kabenuke(0, TRUE);
1613                         set_tim_res_nether(0, TRUE);
1614                         set_tim_res_time(0, TRUE);
1615                         /* by henkma */
1616                         set_tim_reflect(0,TRUE);
1617                         set_multishadow(0,TRUE);
1618                         set_dustrobe(0,TRUE);
1619
1620                         set_tim_invis(0, TRUE);
1621                         set_tim_infra(0, TRUE);
1622                         set_tim_esp(0, TRUE);
1623                         set_tim_regen(0, TRUE);
1624                         set_tim_stealth(0, TRUE);
1625                         set_tim_ffall(0, TRUE);
1626                         set_tim_sh_touki(0, TRUE);
1627                         set_tim_sh_fire(0, TRUE);
1628                         set_tim_sh_holy(0, TRUE);
1629                         set_tim_eyeeye(0, TRUE);
1630                         set_magicdef(0, TRUE);
1631                         set_resist_magic(0, TRUE);
1632                         set_oppose_acid(0, TRUE);
1633                         set_oppose_elec(0, TRUE);
1634                         set_oppose_fire(0, TRUE);
1635                         set_oppose_cold(0, TRUE);
1636                         set_oppose_pois(0, TRUE);
1637                         set_ultimate_res(0, TRUE);
1638                         set_mimic(0, 0, TRUE);
1639                         set_ele_attack(0, 0);
1640                         set_ele_immune(0, 0);
1641                         /* Cancel glowing hands */
1642                         if (p_ptr->special_attack & ATTACK_CONFUSE)
1643                         {
1644                                 p_ptr->special_attack &= ~(ATTACK_CONFUSE);
1645 #ifdef JP
1646                                 msg_print("¼ê¤Îµ±¤¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
1647 #else
1648                                 msg_print("Your hands stop glowing.");
1649 #endif
1650
1651                         }
1652                         if ((p_ptr->pclass == CLASS_BARD) && (p_ptr->magic_num1[0]))
1653                         {
1654                                 p_ptr->magic_num1[1] = p_ptr->magic_num1[0];
1655                                 p_ptr->magic_num1[0] = 0;
1656 #ifdef JP
1657                                 msg_print("²Î¤¬ÅÓÀÚ¤ì¤¿¡£");
1658 #else
1659                                 msg_print("Your singing is interrupted.");
1660 #endif
1661                                 p_ptr->action = ACTION_NONE;
1662
1663                                 /* Recalculate bonuses */
1664                                 p_ptr->update |= (PU_BONUS | PU_HP);
1665
1666                                 /* Redraw map */
1667                                 p_ptr->redraw |= (PR_MAP | PR_STATUS | PR_STATE);
1668
1669                                 /* Update monsters */
1670                                 p_ptr->update |= (PU_MONSTERS);
1671
1672                                 /* Window stuff */
1673                                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1674
1675                                 p_ptr->energy_need += ENERGY_NEED();
1676                         }
1677                         if (p_ptr->riding)
1678                         {
1679                                 m_list[p_ptr->riding].invulner = 0;
1680                                 m_list[p_ptr->riding].fast = 0;
1681                                 m_list[p_ptr->riding].slow = 0;
1682                                 p_ptr->update |= PU_BONUS;
1683                                 if (p_ptr->health_who == p_ptr->riding) p_ptr->redraw |= PR_HEALTH;
1684                                 p_ptr->redraw |= (PR_UHEALTH);
1685                         }
1686
1687 #ifdef JP
1688                         if ((p_ptr->pseikaku == SEIKAKU_COMBAT) || (inventory[INVEN_BOW].name1 == ART_CRIMSON))
1689                                 msg_print("¤ä¤ê¤ä¤¬¤Ã¤¿¤Ê¡ª");
1690 #endif
1691                         learn_spell(MS_DISPEL);
1692                         break;
1693                 }
1694
1695                 /* RF4_XXX4X4 */
1696                 case 96+3:
1697                 {
1698                         disturb(1, 0);
1699 #ifdef JP
1700 if (blind) msg_format("%^s¤¬²¿¤«¤ò¼Í¤Ã¤¿¡£", m_name);
1701 #else
1702                         if (blind) msg_format("%^s shoots something.", m_name);
1703 #endif
1704
1705 #ifdef JP
1706 else msg_format("%^s¤¬¥í¥±¥Ã¥È¤òÈ¯¼Í¤·¤¿¡£", m_name);
1707 #else
1708                         else msg_format("%^s fires a rocket.", m_name);
1709 #endif
1710
1711                         dam = ((m_ptr->hp / 4) > 800 ? 800 : (m_ptr->hp / 4));
1712                         breath(y, x, m_idx, GF_ROCKET,
1713                                 dam, 2, FALSE, MS_ROCKET, learnable);
1714                         update_smart_learn(m_idx, DRS_SHARD);
1715                         break;
1716                 }
1717
1718                 /* RF4_SHOOT */
1719                 case 96+4:
1720                 {
1721                         if (x!=px || y!=py) return (FALSE);
1722                         disturb(1, 0);
1723 #ifdef JP
1724 if (blind) msg_format("%^s¤¬´ñÌ¯¤Ê²»¤òÈ¯¤·¤¿¡£", m_name);
1725 #else
1726                         if (blind) msg_format("%^s makes a strange noise.", m_name);
1727 #endif
1728
1729 #ifdef JP
1730 else msg_format("%^s¤¬Ìð¤òÊü¤Ã¤¿¡£", m_name);
1731 #else
1732                         else msg_format("%^s fires an arrow.", m_name);
1733 #endif
1734
1735                         dam = damroll(r_ptr->blow[0].d_dice, r_ptr->blow[0].d_side);
1736                         bolt(m_idx, GF_ARROW, dam, MS_SHOOT, learnable);
1737                         update_smart_learn(m_idx, DRS_REFLECT);
1738                         break;
1739                 }
1740
1741                 /* RF4_XXX2 */
1742                 case 96+5:
1743                 {
1744                         /* XXX XXX XXX */
1745                         break;
1746                 }
1747
1748                 /* RF4_XXX3 */
1749                 case 96+6:
1750                 {
1751                         /* XXX XXX XXX */
1752                         break;
1753                 }
1754
1755                 /* RF4_XXX4 */
1756                 case 96+7:
1757                 {
1758                         /* XXX XXX XXX */
1759                         break;
1760                 }
1761
1762                 /* RF4_BR_ACID */
1763                 case 96+8:
1764                 {
1765                         disturb(1, 0);
1766 #ifdef JP
1767 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1768 #else
1769                         if (blind) msg_format("%^s breathes.", m_name);
1770 #endif
1771
1772 #ifdef JP
1773 else msg_format("%^s¤¬»À¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1774 #else
1775                         else msg_format("%^s breathes acid.", m_name);
1776 #endif
1777
1778                         dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
1779                         breath(y, x, m_idx, GF_ACID, dam, 0, TRUE, MS_BR_ACID, learnable);
1780                         update_smart_learn(m_idx, DRS_ACID);
1781                         break;
1782                 }
1783
1784                 /* RF4_BR_ELEC */
1785                 case 96+9:
1786                 {
1787                         disturb(1, 0);
1788 #ifdef JP
1789 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1790 #else
1791                         if (blind) msg_format("%^s breathes.", m_name);
1792 #endif
1793
1794 #ifdef JP
1795 else msg_format("%^s¤¬°ðºÊ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1796 #else
1797                         else msg_format("%^s breathes lightning.", m_name);
1798 #endif
1799
1800                         dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
1801                         breath(y, x, m_idx, GF_ELEC, dam,0, TRUE, MS_BR_ELEC, learnable);
1802                         update_smart_learn(m_idx, DRS_ELEC);
1803                         break;
1804                 }
1805
1806                 /* RF4_BR_FIRE */
1807                 case 96+10:
1808                 {
1809                         disturb(1, 0);
1810 #ifdef JP
1811 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1812 #else
1813                         if (blind) msg_format("%^s breathes.", m_name);
1814 #endif
1815
1816 #ifdef JP
1817 else msg_format("%^s¤¬²Ð±ê¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1818 #else
1819                         else msg_format("%^s breathes fire.", m_name);
1820 #endif
1821
1822                         dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
1823                         breath(y, x, m_idx, GF_FIRE, dam,0, TRUE, MS_BR_FIRE, learnable);
1824                         update_smart_learn(m_idx, DRS_FIRE);
1825                         break;
1826                 }
1827
1828                 /* RF4_BR_COLD */
1829                 case 96+11:
1830                 {
1831                         disturb(1, 0);
1832 #ifdef JP
1833 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1834 #else
1835                         if (blind) msg_format("%^s breathes.", m_name);
1836 #endif
1837
1838 #ifdef JP
1839 else msg_format("%^s¤¬Îäµ¤¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1840 #else
1841                         else msg_format("%^s breathes frost.", m_name);
1842 #endif
1843
1844                         dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
1845                         breath(y, x, m_idx, GF_COLD, dam,0, TRUE, MS_BR_COLD, learnable);
1846                         update_smart_learn(m_idx, DRS_COLD);
1847                         break;
1848                 }
1849
1850                 /* RF4_BR_POIS */
1851                 case 96+12:
1852                 {
1853                         disturb(1, 0);
1854 #ifdef JP
1855 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1856 #else
1857                         if (blind) msg_format("%^s breathes.", m_name);
1858 #endif
1859
1860 #ifdef JP
1861 else msg_format("%^s¤¬¥¬¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1862 #else
1863                         else msg_format("%^s breathes gas.", m_name);
1864 #endif
1865
1866                         dam = ((m_ptr->hp / 3) > 800 ? 800 : (m_ptr->hp / 3));
1867                         breath(y, x, m_idx, GF_POIS, dam, 0, TRUE, MS_BR_POIS, learnable);
1868                         update_smart_learn(m_idx, DRS_POIS);
1869                         break;
1870                 }
1871
1872
1873                 /* RF4_BR_NETH */
1874                 case 96+13:
1875                 {
1876                         disturb(1, 0);
1877 #ifdef JP
1878 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1879 #else
1880                         if (blind) msg_format("%^s breathes.", m_name);
1881 #endif
1882
1883 #ifdef JP
1884 else msg_format("%^s¤¬ÃÏ¹ö¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1885 #else
1886                         else msg_format("%^s breathes nether.", m_name);
1887 #endif
1888
1889                         dam = ((m_ptr->hp / 6) > 550 ? 550 : (m_ptr->hp / 6));
1890                         breath(y, x, m_idx, GF_NETHER, dam,0, TRUE, MS_BR_NETHER, learnable);
1891                         update_smart_learn(m_idx, DRS_NETH);
1892                         break;
1893                 }
1894
1895                 /* RF4_BR_LITE */
1896                 case 96+14:
1897                 {
1898                         disturb(1, 0);
1899 #ifdef JP
1900 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1901 #else
1902                         if (blind) msg_format("%^s breathes.", m_name);
1903 #endif
1904
1905 #ifdef JP
1906 else msg_format("%^s¤¬Á®¸÷¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1907 #else
1908                         else msg_format("%^s breathes light.", m_name);
1909 #endif
1910
1911                         dam = ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6));
1912                         breath(y, x, m_idx, GF_LITE, dam,0, TRUE, MS_BR_LITE, learnable);
1913                         update_smart_learn(m_idx, DRS_LITE);
1914                         break;
1915                 }
1916
1917                 /* RF4_BR_DARK */
1918                 case 96+15:
1919                 {
1920                         disturb(1, 0);
1921 #ifdef JP
1922 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1923 #else
1924                         if (blind) msg_format("%^s breathes.", m_name);
1925 #endif
1926
1927 #ifdef JP
1928 else msg_format("%^s¤¬°Å¹õ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1929 #else
1930                         else msg_format("%^s breathes darkness.", m_name);
1931 #endif
1932
1933                         dam = ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6));
1934                         breath(y, x, m_idx, GF_DARK, dam,0, TRUE, MS_BR_DARK, learnable);
1935                         update_smart_learn(m_idx, DRS_DARK);
1936                         break;
1937                 }
1938
1939                 /* RF4_BR_CONF */
1940                 case 96+16:
1941                 {
1942                         disturb(1, 0);
1943 #ifdef JP
1944 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1945 #else
1946                         if (blind) msg_format("%^s breathes.", m_name);
1947 #endif
1948
1949 #ifdef JP
1950 else msg_format("%^s¤¬º®Íð¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1951 #else
1952                         else msg_format("%^s breathes confusion.", m_name);
1953 #endif
1954
1955                         dam = ((m_ptr->hp / 6) > 450 ? 450 : (m_ptr->hp / 6));
1956                         breath(y, x, m_idx, GF_CONFUSION, dam,0, TRUE, MS_BR_CONF, learnable);
1957                         update_smart_learn(m_idx, DRS_CONF);
1958                         break;
1959                 }
1960
1961                 /* RF4_BR_SOUN */
1962                 case 96+17:
1963                 {
1964                         disturb(1, 0);
1965                         if (m_ptr->r_idx == MON_JAIAN)
1966 #ifdef JP
1967                                 msg_format("¡Ö¥Ü¥©¥¨¡Á¡Á¡Á¡Á¡Á¡Á¡×");
1968 #else
1969                                 msg_format("'Booooeeeeee'");
1970 #endif
1971 #ifdef JP
1972 else if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1973 #else
1974                         else if (blind) msg_format("%^s breathes.", m_name);
1975 #endif
1976
1977 #ifdef JP
1978 else msg_format("%^s¤¬¹ì²»¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1979 #else
1980                         else msg_format("%^s breathes sound.", m_name);
1981 #endif
1982
1983                         dam = ((m_ptr->hp / 6) > 450 ? 450 : (m_ptr->hp / 6));
1984                         breath(y, x, m_idx, GF_SOUND, dam,0, TRUE, MS_BR_SOUND, learnable);
1985                         update_smart_learn(m_idx, DRS_SOUND);
1986                         break;
1987                 }
1988
1989                 /* RF4_BR_CHAO */
1990                 case 96+18:
1991                 {
1992                         disturb(1, 0);
1993 #ifdef JP
1994 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1995 #else
1996                         if (blind) msg_format("%^s breathes.", m_name);
1997 #endif
1998
1999 #ifdef JP
2000 else msg_format("%^s¤¬¥«¥ª¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2001 #else
2002                         else msg_format("%^s breathes chaos.", m_name);
2003 #endif
2004
2005                         dam = ((m_ptr->hp / 6) > 600 ? 600 : (m_ptr->hp / 6));
2006                         breath(y, x, m_idx, GF_CHAOS, dam,0, TRUE, MS_BR_CHAOS, learnable);
2007                         update_smart_learn(m_idx, DRS_CHAOS);
2008                         break;
2009                 }
2010
2011                 /* RF4_BR_DISE */
2012                 case 96+19:
2013                 {
2014                         disturb(1, 0);
2015 #ifdef JP
2016 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2017 #else
2018                         if (blind) msg_format("%^s breathes.", m_name);
2019 #endif
2020
2021 #ifdef JP
2022 else msg_format("%^s¤¬Îô²½¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2023 #else
2024                         else msg_format("%^s breathes disenchantment.", m_name);
2025 #endif
2026
2027                         dam = ((m_ptr->hp / 6) > 500 ? 500 : (m_ptr->hp / 6));
2028                         breath(y, x, m_idx, GF_DISENCHANT, dam,0, TRUE, MS_BR_DISEN, learnable);
2029                         update_smart_learn(m_idx, DRS_DISEN);
2030                         break;
2031                 }
2032
2033                 /* RF4_BR_NEXU */
2034                 case 96+20:
2035                 {
2036                         disturb(1, 0);
2037 #ifdef JP
2038 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2039 #else
2040                         if (blind) msg_format("%^s breathes.", m_name);
2041 #endif
2042
2043 #ifdef JP
2044 else msg_format("%^s¤¬°ø²Ìº®Íð¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2045 #else
2046                         else msg_format("%^s breathes nexus.", m_name);
2047 #endif
2048
2049                         dam = ((m_ptr->hp / 3) > 250 ? 250 : (m_ptr->hp / 3));
2050                         breath(y, x, m_idx, GF_NEXUS, dam,0, TRUE, MS_BR_NEXUS, learnable);
2051                         update_smart_learn(m_idx, DRS_NEXUS);
2052                         break;
2053                 }
2054
2055                 /* RF4_BR_TIME */
2056                 case 96+21:
2057                 {
2058                         disturb(1, 0);
2059 #ifdef JP
2060 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2061 #else
2062                         if (blind) msg_format("%^s breathes.", m_name);
2063 #endif
2064
2065 #ifdef JP
2066 else msg_format("%^s¤¬»þ´ÖµÕÅ¾¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2067 #else
2068                         else msg_format("%^s breathes time.", m_name);
2069 #endif
2070
2071                         dam = ((m_ptr->hp / 3) > 150 ? 150 : (m_ptr->hp / 3));
2072                         breath(y, x, m_idx, GF_TIME, dam,0, TRUE, MS_BR_TIME, learnable);
2073                         break;
2074                 }
2075
2076                 /* RF4_BR_INER */
2077                 case 96+22:
2078                 {
2079                         disturb(1, 0);
2080 #ifdef JP
2081 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2082 #else
2083                         if (blind) msg_format("%^s breathes.", m_name);
2084 #endif
2085
2086 #ifdef JP
2087 else msg_format("%^s¤¬ÃÙÆß¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2088 #else
2089                         else msg_format("%^s breathes inertia.", m_name);
2090 #endif
2091
2092                         dam = ((m_ptr->hp / 6) > 200 ? 200 : (m_ptr->hp / 6));
2093                         breath(y, x, m_idx, GF_INERTIA, dam,0, TRUE, MS_BR_INERTIA, learnable);
2094                         break;
2095                 }
2096
2097                 /* RF4_BR_GRAV */
2098                 case 96+23:
2099                 {
2100                         disturb(1, 0);
2101 #ifdef JP
2102 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2103 #else
2104                         if (blind) msg_format("%^s breathes.", m_name);
2105 #endif
2106
2107 #ifdef JP
2108 else msg_format("%^s¤¬½ÅÎÏ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2109 #else
2110                         else msg_format("%^s breathes gravity.", m_name);
2111 #endif
2112
2113                         dam = ((m_ptr->hp / 3) > 200 ? 200 : (m_ptr->hp / 3));
2114                         breath(y, x, m_idx, GF_GRAVITY, dam,0, TRUE, MS_BR_GRAVITY, learnable);
2115                         break;
2116                 }
2117
2118                 /* RF4_BR_SHAR */
2119                 case 96+24:
2120                 {
2121                         disturb(1, 0);
2122                         if (m_ptr->r_idx == MON_BOTEI)
2123 #ifdef JP
2124                                 msg_format("¡Ö¥ÜÄë¥Ó¥ë¥«¥Ã¥¿¡¼¡ª¡ª¡ª¡×");
2125 #else
2126                                 msg_format("'Boty-Build cutter!!!'");
2127 #endif
2128 #ifdef JP
2129 else if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2130 #else
2131                         else if (blind) msg_format("%^s breathes.", m_name);
2132 #endif
2133
2134 #ifdef JP
2135 else msg_format("%^s¤¬ÇËÊÒ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2136 #else
2137                         else msg_format("%^s breathes shards.", m_name);
2138 #endif
2139
2140                         dam = ((m_ptr->hp / 6) > 500 ? 500 : (m_ptr->hp / 6));
2141                         breath(y, x, m_idx, GF_SHARDS, dam,0, TRUE, MS_BR_SHARDS, learnable);
2142                         update_smart_learn(m_idx, DRS_SHARD);
2143                         break;
2144                 }
2145
2146                 /* RF4_BR_PLAS */
2147                 case 96+25:
2148                 {
2149                         disturb(1, 0);
2150 #ifdef JP
2151 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2152 #else
2153                         if (blind) msg_format("%^s breathes.", m_name);
2154 #endif
2155
2156 #ifdef JP
2157 else msg_format("%^s¤¬¥×¥é¥º¥Þ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2158 #else
2159                         else msg_format("%^s breathes plasma.", m_name);
2160 #endif
2161
2162                         dam = ((m_ptr->hp / 6) > 150 ? 150 : (m_ptr->hp / 6));
2163                         breath(y, x, m_idx, GF_PLASMA, dam,0, TRUE, MS_BR_PLASMA, learnable);
2164                         break;
2165                 }
2166
2167                 /* RF4_BR_WALL */
2168                 case 96+26:
2169                 {
2170                         disturb(1, 0);
2171 #ifdef JP
2172 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2173 #else
2174                         if (blind) msg_format("%^s breathes.", m_name);
2175 #endif
2176
2177 #ifdef JP
2178 else msg_format("%^s¤¬¥Õ¥©¡¼¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2179 #else
2180                         else msg_format("%^s breathes force.", m_name);
2181 #endif
2182
2183                         dam = ((m_ptr->hp / 6) > 200 ? 200 : (m_ptr->hp / 6));
2184                         breath(y, x, m_idx, GF_FORCE, dam,0, TRUE, MS_BR_FORCE, learnable);
2185                         break;
2186                 }
2187
2188                 /* RF4_BR_MANA */
2189                 case 96+27:
2190                 {
2191                         disturb(1, 0);
2192 #ifdef JP
2193 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2194 #else
2195                         if (blind) msg_format("%^s breathes.", m_name);
2196 #endif
2197
2198 #ifdef JP
2199 else msg_format("%^s¤¬ËâÎÏ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2200 #else
2201                         else msg_format("%^s breathes mana.", m_name);
2202 #endif
2203                         dam = ((m_ptr->hp / 3) > 250 ? 250 : (m_ptr->hp / 3));
2204                         breath(y, x, m_idx, GF_MANA, dam,0, TRUE, MS_BR_MANA, learnable);
2205                         break;
2206                 }
2207
2208                 /* RF4_BA_NUKE */
2209                 case 96+28:
2210                 {
2211                         disturb(1, 0);
2212 #ifdef JP
2213 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2214 #else
2215                         if (blind) msg_format("%^s mumbles.", m_name);
2216 #endif
2217
2218 #ifdef JP
2219 else msg_format("%^s¤¬Êü¼ÍÇ½µå¤òÊü¤Ã¤¿¡£", m_name);
2220 #else
2221                         else msg_format("%^s casts a ball of radiation.", m_name);
2222 #endif
2223
2224                         dam = (rlev + damroll(10, 6)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2225                         breath(y, x, m_idx, GF_NUKE, dam, 2, FALSE, MS_BALL_NUKE, learnable);
2226                         update_smart_learn(m_idx, DRS_POIS);
2227                         break;
2228                 }
2229
2230                 /* RF4_BR_NUKE */
2231                 case 96+29:
2232                 {
2233                         disturb(1, 0);
2234 #ifdef JP
2235 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2236 #else
2237                         if (blind) msg_format("%^s breathes.", m_name);
2238 #endif
2239
2240 #ifdef JP
2241 else msg_format("%^s¤¬Êü¼ÍÀÇÑ´þÊª¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2242 #else
2243                         else msg_format("%^s breathes toxic waste.", m_name);
2244 #endif
2245
2246                         dam = ((m_ptr->hp / 3) > 800 ? 800 : (m_ptr->hp / 3));
2247                         breath(y, x, m_idx, GF_NUKE, dam,0, TRUE, MS_BR_NUKE, learnable);
2248                         update_smart_learn(m_idx, DRS_POIS);
2249                         break;
2250                 }
2251
2252                 /* RF4_BA_CHAO */
2253                 case 96+30:
2254                 {
2255                         disturb(1, 0);
2256 #ifdef JP
2257 if (blind) msg_format("%^s¤¬¶²¤í¤·¤²¤Ë¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2258 #else
2259                         if (blind) msg_format("%^s mumbles frighteningly.", m_name);
2260 #endif
2261
2262 #ifdef JP
2263 else msg_format("%^s¤¬½ã¥í¥°¥ë¥¹¤òÊü¤Ã¤¿¡£", m_name);/*nuke me*/
2264 #else
2265                         else msg_format("%^s invokes a raw Logrus.", m_name);
2266 #endif
2267
2268                         dam = ((r_ptr->flags2 & RF2_POWERFUL) ? (rlev * 3) : (rlev * 2))+ damroll(10, 10);
2269                         breath(y, x, m_idx, GF_CHAOS, dam, 4, FALSE, MS_BALL_CHAOS, learnable);
2270                         update_smart_learn(m_idx, DRS_CHAOS);
2271                         break;
2272                 }
2273
2274                 /* RF4_BR_DISI */
2275                 case 96+31:
2276                 {
2277                         disturb(1, 0);
2278 #ifdef JP
2279 if (blind) msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2280 #else
2281                         if (blind) msg_format("%^s breathes.", m_name);
2282 #endif
2283
2284 #ifdef JP
2285 else msg_format("%^s¤¬Ê¬²ò¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
2286 #else
2287                         else msg_format("%^s breathes disintegration.", m_name);
2288 #endif
2289
2290                         dam = ((m_ptr->hp / 6) > 150 ? 150 : (m_ptr->hp / 6));
2291                         breath(y, x, m_idx, GF_DISINTEGRATE, dam,0, TRUE, MS_BR_DISI, learnable);
2292                         break;
2293                 }
2294
2295
2296
2297                 /* RF5_BA_ACID */
2298                 case 128+0:
2299                 {
2300                         disturb(1, 0);
2301 #ifdef JP
2302 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2303 #else
2304                         if (blind) msg_format("%^s mumbles.", m_name);
2305 #endif
2306
2307 #ifdef JP
2308 else msg_format("%^s¤¬¥¢¥·¥Ã¥É¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2309 #else
2310                         else msg_format("%^s casts an acid ball.", m_name);
2311 #endif
2312
2313                         dam = (randint1(rlev * 3) + 15) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2314                         breath(y, x, m_idx, GF_ACID, dam, 2, FALSE, MS_BALL_ACID, learnable);
2315                         update_smart_learn(m_idx, DRS_ACID);
2316                         break;
2317                 }
2318
2319                 /* RF5_BA_ELEC */
2320                 case 128+1:
2321                 {
2322                         disturb(1, 0);
2323 #ifdef JP
2324 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2325 #else
2326                         if (blind) msg_format("%^s mumbles.", m_name);
2327 #endif
2328
2329 #ifdef JP
2330 else msg_format("%^s¤¬¥µ¥ó¥À¡¼¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2331 #else
2332                         else msg_format("%^s casts a lightning ball.", m_name);
2333 #endif
2334
2335                         dam = (randint1(rlev * 3 / 2) + 8) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2336                         breath(y, x, m_idx, GF_ELEC, dam, 2, FALSE, MS_BALL_ELEC, learnable);
2337                         update_smart_learn(m_idx, DRS_ELEC);
2338                         break;
2339                 }
2340
2341                 /* RF5_BA_FIRE */
2342                 case 128+2:
2343                 {
2344                         disturb(1, 0);
2345
2346                         if (m_ptr->r_idx == MON_ROLENTO)
2347                         {
2348 #ifdef JP
2349                                 if (blind)
2350                                         msg_format("%s¤¬²¿¤«¤òÅê¤²¤¿¡£", m_name);
2351                                 else
2352                                         msg_format("%s¤Ï¼êÜØÃÆ¤òÅê¤²¤¿¡£", m_name);
2353 #else
2354                                 if (blind)
2355                                         msg_format("%^s throws something.", m_name);
2356                                 else
2357                                         msg_format("%^s throws a hand grenade.", m_name);
2358 #endif
2359                         }
2360                         else
2361                         {
2362 #ifdef JP
2363 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2364 #else
2365                                 if (blind) msg_format("%^s mumbles.", m_name);
2366 #endif
2367
2368 #ifdef JP
2369 else msg_format("%^s¤¬¥Õ¥¡¥¤¥¢¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2370 #else
2371                                 else msg_format("%^s casts a fire ball.", m_name);
2372 #endif
2373                         }
2374
2375                         dam = (randint1(rlev * 7 / 2) + 10) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2376                         breath(y, x, m_idx, GF_FIRE, dam, 2, FALSE, MS_BALL_FIRE, learnable);
2377                         update_smart_learn(m_idx, DRS_FIRE);
2378                         break;
2379                 }
2380
2381                 /* RF5_BA_COLD */
2382                 case 128+3:
2383                 {
2384                         disturb(1, 0);
2385 #ifdef JP
2386 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2387 #else
2388                         if (blind) msg_format("%^s mumbles.", m_name);
2389 #endif
2390
2391 #ifdef JP
2392 else msg_format("%^s¤¬¥¢¥¤¥¹¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2393 #else
2394                         else msg_format("%^s casts a frost ball.", m_name);
2395 #endif
2396
2397                         dam = (randint1(rlev * 3 / 2) + 10) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2398                         breath(y, x, m_idx, GF_COLD, dam, 2, FALSE, MS_BALL_COLD, learnable);
2399                         update_smart_learn(m_idx, DRS_COLD);
2400                         break;
2401                 }
2402
2403                 /* RF5_BA_POIS */
2404                 case 128+4:
2405                 {
2406                         disturb(1, 0);
2407 #ifdef JP
2408 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2409 #else
2410                         if (blind) msg_format("%^s mumbles.", m_name);
2411 #endif
2412
2413 #ifdef JP
2414 else msg_format("%^s¤¬°½±À¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2415 #else
2416                         else msg_format("%^s casts a stinking cloud.", m_name);
2417 #endif
2418
2419                         dam = damroll(12, 2) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2420                         breath(y, x, m_idx, GF_POIS, dam, 2, FALSE, MS_BALL_POIS, learnable);
2421                         update_smart_learn(m_idx, DRS_POIS);
2422                         break;
2423                 }
2424
2425                 /* RF5_BA_NETH */
2426                 case 128+5:
2427                 {
2428                         disturb(1, 0);
2429 #ifdef JP
2430 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2431 #else
2432                         if (blind) msg_format("%^s mumbles.", m_name);
2433 #endif
2434
2435 #ifdef JP
2436 else msg_format("%^s¤¬ÃÏ¹öµå¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2437 #else
2438                         else msg_format("%^s casts a nether ball.", m_name);
2439 #endif
2440
2441                         dam = 50 + damroll(10, 10) + (rlev * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1));
2442                         breath(y, x, m_idx, GF_NETHER, dam, 2, FALSE, MS_BALL_NETHER, learnable);
2443                         update_smart_learn(m_idx, DRS_NETH);
2444                         break;
2445                 }
2446
2447                 /* RF5_BA_WATE */
2448                 case 128+6:
2449                 {
2450                         disturb(1, 0);
2451 #ifdef JP
2452 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2453 #else
2454                         if (blind) msg_format("%^s mumbles.", m_name);
2455 #endif
2456
2457 #ifdef JP
2458 else msg_format("%^s¤¬Î®¤ì¤ë¤è¤¦¤Ê¿È¿¶¤ê¤ò¤·¤¿¡£", m_name);
2459 #else
2460                         else msg_format("%^s gestures fluidly.", m_name);
2461 #endif
2462
2463 #ifdef JP
2464 msg_print("¤¢¤Ê¤¿¤Ï±²´¬¤¤Ë°û¤ß¹þ¤Þ¤ì¤¿¡£");
2465 #else
2466                         msg_print("You are engulfed in a whirlpool.");
2467 #endif
2468
2469                         dam = ((r_ptr->flags2 & RF2_POWERFUL) ? randint1(rlev * 3) : randint1(rlev * 2)) + 50;
2470                         breath(y, x, m_idx, GF_WATER, dam, 4, FALSE, MS_BALL_WATER, learnable);
2471                         break;
2472                 }
2473
2474                 /* RF5_BA_MANA */
2475                 case 128+7:
2476                 {
2477                         disturb(1, 0);
2478 #ifdef JP
2479 if (blind) msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2480 #else
2481                         if (blind) msg_format("%^s mumbles powerfully.", m_name);
2482 #endif
2483
2484 #ifdef JP
2485 else msg_format("%^s¤¬ËâÎÏ¤ÎÍò¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name);
2486 #else
2487                         else msg_format("%^s invokes a mana storm.", m_name);
2488 #endif
2489
2490                         dam = (rlev * 4) + 50 + damroll(10, 10);
2491                         breath(y, x, m_idx, GF_MANA, dam, 4, FALSE, MS_BALL_MANA, learnable);
2492                         break;
2493                 }
2494
2495                 /* RF5_BA_DARK */
2496                 case 128+8:
2497                 {
2498                         disturb(1, 0);
2499 #ifdef JP
2500 if (blind) msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2501 #else
2502                         if (blind) msg_format("%^s mumbles powerfully.", m_name);
2503 #endif
2504
2505 #ifdef JP
2506 else msg_format("%^s¤¬°Å¹õ¤ÎÍò¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name);
2507 #else
2508                         else msg_format("%^s invokes a darkness storm.", m_name);
2509 #endif
2510
2511                         dam = (rlev * 4) + 50 + damroll(10, 10);
2512                         breath(y, x, m_idx, GF_DARK, dam, 4, FALSE, MS_BALL_DARK, learnable);
2513                         update_smart_learn(m_idx, DRS_DARK);
2514                         break;
2515                 }
2516
2517                 /* RF5_DRAIN_MANA */
2518                 case 128+9:
2519                 {
2520                         if (x!=px || y!=py) return (FALSE);
2521                         if (!direct) break;
2522                         disturb(1, 0);
2523                         if (p_ptr->csp)
2524                         {
2525                                 int r1;
2526
2527                                 /* Basic message */
2528 #ifdef JP
2529 msg_format("%^s¤ËÀº¿À¥¨¥Í¥ë¥®¡¼¤òµÛ¤¤¼è¤é¤ì¤Æ¤·¤Þ¤Ã¤¿¡ª", m_name);
2530 #else
2531                                 msg_format("%^s draws psychic energy from you!", m_name);
2532 #endif
2533
2534
2535                                 /* Attack power */
2536                                 r1 = (randint1(rlev) / 2) + 1;
2537
2538                                 /* Full drain */
2539                                 if (r1 >= p_ptr->csp)
2540                                 {
2541                                         r1 = p_ptr->csp;
2542                                         p_ptr->csp = 0;
2543                                         p_ptr->csp_frac = 0;
2544                                 }
2545
2546                                 /* Partial drain */
2547                                 else
2548                                 {
2549                                         p_ptr->csp -= r1;
2550                                 }
2551
2552                                 learn_spell(MS_DRAIN_MANA);
2553
2554                                 /* Redraw mana */
2555                                 p_ptr->redraw |= (PR_MANA);
2556
2557                                 /* Window stuff */
2558                                 p_ptr->window |= (PW_PLAYER);
2559                                 p_ptr->window |= (PW_SPELL);
2560
2561                                 /* Heal the monster */
2562                                 if (m_ptr->hp < m_ptr->maxhp)
2563                                 {
2564                                         /* Heal */
2565                                         m_ptr->hp += (6 * r1);
2566                                         if (m_ptr->hp > m_ptr->maxhp) m_ptr->hp = m_ptr->maxhp;
2567
2568                                         /* Redraw (later) if needed */
2569                                         if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
2570                                         if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
2571
2572                                         /* Special message */
2573                                         if (seen)
2574                                         {
2575 #ifdef JP
2576 msg_format("%^s¤Ïµ¤Ê¬¤¬ÎÉ¤µ¤½¤¦¤À¡£", m_name);
2577 #else
2578                                                 msg_format("%^s appears healthier.", m_name);
2579 #endif
2580
2581                                         }
2582                                 }
2583                         }
2584                         update_smart_learn(m_idx, DRS_MANA);
2585                         break;
2586                 }
2587
2588                 /* RF5_MIND_BLAST */
2589                 case 128+10:
2590                 {
2591                         if (x!=px || y!=py) return (FALSE);
2592                         if (!direct) break;
2593                         disturb(1, 0);
2594                         if (!seen)
2595                         {
2596 #ifdef JP
2597 msg_print("²¿¤«¤¬¤¢¤Ê¤¿¤ÎÀº¿À¤ËÇ°¤òÊü¤Ã¤Æ¤¤¤ë¤è¤¦¤À¡£");
2598 #else
2599                                 msg_print("You feel something focusing on your mind.");
2600 #endif
2601
2602                         }
2603                         else
2604                         {
2605 #ifdef JP
2606 msg_format("%^s¤¬¤¢¤Ê¤¿¤ÎÆ·¤ò¤¸¤Ã¤È¤Ë¤é¤ó¤Ç¤¤¤ë¡£", m_name);
2607 #else
2608                                 msg_format("%^s gazes deep into your eyes.", m_name);
2609 #endif
2610
2611                         }
2612
2613                         dam = damroll(7, 7);
2614                         if (randint0(100 + rlev/2) < (MAX(5, p_ptr->skill_sav)))
2615                         {
2616 #ifdef JP
2617 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
2618 #else
2619                                 msg_print("You resist the effects!");
2620 #endif
2621                                 learn_spell(MS_MIND_BLAST);
2622                         }
2623                         else
2624                         {
2625 #ifdef JP
2626 msg_print("ÎîÅª¥¨¥Í¥ë¥®¡¼¤ÇÀº¿À¤¬¹¶·â¤µ¤ì¤¿¡£");
2627 #else
2628                                 msg_print("Your mind is blasted by psyonic energy.");
2629 #endif
2630
2631                                 if (!p_ptr->resist_conf)
2632                                 {
2633                                         (void)set_confused(p_ptr->confused + randint0(4) + 4);
2634                                 }
2635
2636                                 if (!p_ptr->resist_chaos && one_in_(3))
2637                                 {
2638                                         (void)set_image(p_ptr->image + randint0(250) + 150);
2639                                 }
2640
2641                                 p_ptr->csp -= 50;
2642                                 if (p_ptr->csp < 0)
2643                                 {
2644                                         p_ptr->csp = 0;
2645                                         p_ptr->csp_frac = 0;
2646                                 }
2647                                 p_ptr->redraw |= PR_MANA;
2648
2649                                 take_hit(DAMAGE_ATTACK, dam, ddesc, MS_MIND_BLAST);
2650                         }
2651                         break;
2652                 }
2653
2654                 /* RF5_BRAIN_SMASH */
2655                 case 128+11:
2656                 {
2657                         if (x!=px || y!=py) return (FALSE);
2658                         if (!direct) break;
2659                         disturb(1, 0);
2660                         if (!seen)
2661                         {
2662 #ifdef JP
2663 msg_print("²¿¤«¤¬¤¢¤Ê¤¿¤ÎÀº¿À¤ËÇ°¤òÊü¤Ã¤Æ¤¤¤ë¤è¤¦¤À¡£");
2664 #else
2665                                 msg_print("You feel something focusing on your mind.");
2666 #endif
2667
2668                         }
2669                         else
2670                         {
2671 #ifdef JP
2672 msg_format("%^s¤¬¤¢¤Ê¤¿¤ÎÆ·¤ò¤¸¤Ã¤È¸«¤Æ¤¤¤ë¡£", m_name);
2673 #else
2674                                 msg_format("%^s looks deep into your eyes.", m_name);
2675 #endif
2676
2677                         }
2678
2679                         dam = damroll(12, 12);
2680                         if (randint0(100 + rlev/2) < (MAX(5, p_ptr->skill_sav)))
2681                         {
2682 #ifdef JP
2683 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
2684 #else
2685                                 msg_print("You resist the effects!");
2686 #endif
2687                                 learn_spell(MS_BRAIN_SMASH);
2688                         }
2689                         else
2690                         {
2691 #ifdef JP
2692 msg_print("ÎîÅª¥¨¥Í¥ë¥®¡¼¤ÇÀº¿À¤¬¹¶·â¤µ¤ì¤¿¡£");
2693 #else
2694                                 msg_print("Your mind is blasted by psionic energy.");
2695 #endif
2696
2697                                 p_ptr->csp -= 100;
2698                                 if (p_ptr->csp < 0)
2699                                 {
2700                                         p_ptr->csp = 0;
2701                                         p_ptr->csp_frac = 0;
2702                                 }
2703                                 p_ptr->redraw |= PR_MANA;
2704
2705                                 take_hit(DAMAGE_ATTACK, dam, ddesc, MS_BRAIN_SMASH);
2706                                 if (!p_ptr->resist_blind)
2707                                 {
2708                                         (void)set_blind(p_ptr->blind + 8 + randint0(8));
2709                                 }
2710                                 if (!p_ptr->resist_conf)
2711                                 {
2712                                         (void)set_confused(p_ptr->confused + randint0(4) + 4);
2713                                 }
2714                                 if (!p_ptr->free_act)
2715                                 {
2716                                         (void)set_paralyzed(p_ptr->paralyzed + randint0(4) + 4);
2717                                 }
2718                                 (void)set_slow(p_ptr->slow + randint0(4) + 4, FALSE);
2719
2720                                 while (randint0(100 + rlev/2) > (MAX(5, p_ptr->skill_sav)))
2721                                         (void)do_dec_stat(A_INT);
2722                                 while (randint0(100 + rlev/2) > (MAX(5, p_ptr->skill_sav)))
2723                                         (void)do_dec_stat(A_WIS);
2724
2725                                 if (!p_ptr->resist_chaos)
2726                                 {
2727                                         (void)set_image(p_ptr->image + randint0(250) + 150);
2728                                 }
2729                         }
2730                         break;
2731                 }
2732
2733                 /* RF5_CAUSE_1 */
2734                 case 128+12:
2735                 {
2736                         if (x!=px || y!=py) return (FALSE);
2737                         if (!direct) break;
2738                         disturb(1, 0);
2739 #ifdef JP
2740 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2741 #else
2742                         if (blind) msg_format("%^s mumbles.", m_name);
2743 #endif
2744
2745 #ifdef JP
2746 else msg_format("%^s¤¬¤¢¤Ê¤¿¤ò»Ø¤µ¤·¤Æ¼ö¤Ã¤¿¡£", m_name);
2747 #else
2748                         else msg_format("%^s points at you and curses.", m_name);
2749 #endif
2750
2751                         dam = damroll(3, 8);
2752                         if (randint0(100 + rlev/2) < p_ptr->skill_sav)
2753                         {
2754 #ifdef JP
2755 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
2756 #else
2757                                 msg_print("You resist the effects!");
2758 #endif
2759                                 learn_spell(MS_CAUSE_1);
2760                         }
2761                         else
2762                         {
2763                                 curse_equipment(15, 0);
2764                                 take_hit(DAMAGE_ATTACK, dam, ddesc, MS_CAUSE_1);
2765                         }
2766                         break;
2767                 }
2768
2769                 /* RF5_CAUSE_2 */
2770                 case 128+13:
2771                 {
2772                         if (x!=px || y!=py) return (FALSE);
2773                         if (!direct) break;
2774                         disturb(1, 0);
2775 #ifdef JP
2776 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2777 #else
2778                         if (blind) msg_format("%^s mumbles.", m_name);
2779 #endif
2780
2781 #ifdef JP
2782 else msg_format("%^s¤¬¤¢¤Ê¤¿¤ò»Ø¤µ¤·¤Æ¶²¤í¤·¤²¤Ë¼ö¤Ã¤¿¡£", m_name);
2783 #else
2784                         else msg_format("%^s points at you and curses horribly.", m_name);
2785 #endif
2786
2787                         dam = damroll(8, 8);
2788                         if (randint0(100 + rlev/2) < p_ptr->skill_sav)
2789                         {
2790 #ifdef JP
2791 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
2792 #else
2793                                 msg_print("You resist the effects!");
2794 #endif
2795                                 learn_spell(MS_CAUSE_2);
2796                         }
2797                         else
2798                         {
2799                                 curse_equipment(25, MIN(rlev/2-15, 5));
2800                                 take_hit(DAMAGE_ATTACK, dam, ddesc, MS_CAUSE_2);
2801                         }
2802                         break;
2803                 }
2804
2805                 /* RF5_CAUSE_3 */
2806                 case 128+14:
2807                 {
2808                         if (x!=px || y!=py) return (FALSE);
2809                         if (!direct) break;
2810                         disturb(1, 0);
2811 #ifdef JP
2812 if (blind) msg_format("%^s¤¬²¿¤«¤òÂçÀ¼¤Ç¶«¤ó¤À¡£", m_name);
2813 #else
2814                         if (blind) msg_format("%^s mumbles loudly.", m_name);
2815 #endif
2816
2817 #ifdef JP
2818 else msg_format("%^s¤¬¤¢¤Ê¤¿¤ò»Ø¤µ¤·¤Æ¶²¤í¤·¤²¤Ë¼öÊ¸¤ò¾§¤¨¤¿¡ª", m_name);
2819 #else
2820                         else msg_format("%^s points at you, incanting terribly!", m_name);
2821 #endif
2822
2823                         dam = damroll(10, 15);
2824                         if (randint0(100 + rlev/2) < p_ptr->skill_sav)
2825                         {
2826 #ifdef JP
2827 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
2828 #else
2829                                 msg_print("You resist the effects!");
2830 #endif
2831                                 learn_spell(MS_CAUSE_3);
2832                         }
2833                         else
2834                         {
2835                                 curse_equipment(33, MIN(rlev/2-15, 15));
2836                                 take_hit(DAMAGE_ATTACK, dam, ddesc, MS_CAUSE_3);
2837                         }
2838                         break;
2839                 }
2840
2841                 /* RF5_CAUSE_4 */
2842                 case 128+15:
2843                 {
2844                         if (x!=px || y!=py) return (FALSE);
2845                         if (!direct) break;
2846                         disturb(1, 0);
2847 #ifdef JP
2848 if (blind) msg_format("%^s¤¬¡Ö¤ªÁ°¤Ï´û¤Ë»à¤ó¤Ç¤¤¤ë¡×¤È¶«¤ó¤À¡£", m_name);
2849 #else
2850                         if (blind) msg_format("%^s screams the word 'DIE!'", m_name);
2851 #endif
2852
2853 #ifdef JP
2854 else msg_format("%^s¤¬¤¢¤Ê¤¿¤ÎÈë¹¦¤òÆÍ¤¤¤Æ¡Ö¤ªÁ°¤Ï´û¤Ë»à¤ó¤Ç¤¤¤ë¡×¤È¶«¤ó¤À¡£", m_name);
2855 #else
2856                         else msg_format("%^s points at you, screaming the word DIE!", m_name);
2857 #endif
2858
2859                         dam = damroll(15, 15);
2860                         if ((randint0(100 + rlev/2) < p_ptr->skill_sav) && !(m_ptr->r_idx == MON_KENSHIROU))
2861                         {
2862 #ifdef JP
2863 msg_print("¤·¤«¤·Èë¹¦¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
2864 #else
2865                                 msg_print("You resist the effects!");
2866 #endif
2867                                 learn_spell(MS_CAUSE_4);
2868                         }
2869                         else
2870                         {
2871                                 take_hit(DAMAGE_ATTACK, dam, ddesc, MS_CAUSE_4);
2872                                 (void)set_cut(p_ptr->cut + damroll(10, 10));
2873                         }
2874                         break;
2875                 }
2876
2877                 /* RF5_BO_ACID */
2878                 case 128+16:
2879                 {
2880                         if (x!=px || y!=py) return (FALSE);
2881                         disturb(1, 0);
2882 #ifdef JP
2883 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2884 #else
2885                         if (blind) msg_format("%^s mumbles.", m_name);
2886 #endif
2887
2888 #ifdef JP
2889 else msg_format("%^s¤¬¥¢¥·¥Ã¥É¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2890 #else
2891                         else msg_format("%^s casts a acid bolt.", m_name);
2892 #endif
2893
2894                         dam = (damroll(7, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2895                         bolt(m_idx, GF_ACID, dam, MS_BOLT_ACID, learnable);
2896                         update_smart_learn(m_idx, DRS_ACID);
2897                         update_smart_learn(m_idx, DRS_REFLECT);
2898                         break;
2899                 }
2900
2901                 /* RF5_BO_ELEC */
2902                 case 128+17:
2903                 {
2904                         if (x!=px || y!=py) return (FALSE);
2905                         disturb(1, 0);
2906 #ifdef JP
2907 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2908 #else
2909                         if (blind) msg_format("%^s mumbles.", m_name);
2910 #endif
2911
2912 #ifdef JP
2913 else msg_format("%^s¤¬¥µ¥ó¥À¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2914 #else
2915                         else msg_format("%^s casts a lightning bolt.", m_name);
2916 #endif
2917
2918                         dam = (damroll(4, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2919                         bolt(m_idx, GF_ELEC, dam, MS_BOLT_ELEC, learnable);
2920                         update_smart_learn(m_idx, DRS_ELEC);
2921                         update_smart_learn(m_idx, DRS_REFLECT);
2922                         break;
2923                 }
2924
2925                 /* RF5_BO_FIRE */
2926                 case 128+18:
2927                 {
2928                         if (x!=px || y!=py) return (FALSE);
2929                         disturb(1, 0);
2930 #ifdef JP
2931 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2932 #else
2933                         if (blind) msg_format("%^s mumbles.", m_name);
2934 #endif
2935
2936 #ifdef JP
2937 else msg_format("%^s¤¬¥Õ¥¡¥¤¥¢¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2938 #else
2939                         else msg_format("%^s casts a fire bolt.", m_name);
2940 #endif
2941
2942                         dam = (damroll(9, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2943                         bolt(m_idx, GF_FIRE, dam, MS_BOLT_FIRE, learnable);
2944                         update_smart_learn(m_idx, DRS_FIRE);
2945                         update_smart_learn(m_idx, DRS_REFLECT);
2946                         break;
2947                 }
2948
2949                 /* RF5_BO_COLD */
2950                 case 128+19:
2951                 {
2952                         if (x!=px || y!=py) return (FALSE);
2953                         disturb(1, 0);
2954 #ifdef JP
2955 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2956 #else
2957                         if (blind) msg_format("%^s mumbles.", m_name);
2958 #endif
2959
2960 #ifdef JP
2961 else msg_format("%^s¤¬¥¢¥¤¥¹¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
2962 #else
2963                         else msg_format("%^s casts a frost bolt.", m_name);
2964 #endif
2965
2966                         dam = (damroll(6, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2967                         bolt(m_idx, GF_COLD, dam, MS_BOLT_COLD, learnable);
2968                         update_smart_learn(m_idx, DRS_COLD);
2969                         update_smart_learn(m_idx, DRS_REFLECT);
2970                         break;
2971                 }
2972
2973                 /* RF5_BA_LITE */
2974                 case 128+20:
2975                 {
2976                         disturb(1, 0);
2977 #ifdef JP
2978 if (blind) msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2979 #else
2980                         if (blind) msg_format("%^s mumbles powerfully.", m_name);
2981 #endif
2982
2983 #ifdef JP
2984 else msg_format("%^s¤¬¥¹¥¿¡¼¥Ð¡¼¥¹¥È¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name);
2985 #else
2986                         else msg_format("%^s invokes a starburst.", m_name);
2987 #endif
2988
2989                         dam = (rlev * 4) + 50 + damroll(10, 10);
2990                         breath(y, x, m_idx, GF_LITE, dam, 4, FALSE, MS_STARBURST, learnable);
2991                         update_smart_learn(m_idx, DRS_LITE);
2992                         break;
2993                 }
2994
2995                 /* RF5_BO_NETH */
2996                 case 128+21:
2997                 {
2998                         if (x!=px || y!=py) return (FALSE);
2999                         disturb(1, 0);
3000 #ifdef JP
3001 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3002 #else
3003                         if (blind) msg_format("%^s mumbles.", m_name);
3004 #endif
3005
3006 #ifdef JP
3007 else msg_format("%^s¤¬ÃÏ¹ö¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3008 #else
3009                         else msg_format("%^s casts a nether bolt.", m_name);
3010 #endif
3011
3012                         dam = 30 + damroll(5, 5) + (rlev * 4) / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3);
3013                         bolt(m_idx, GF_NETHER, dam, MS_BOLT_NETHER, learnable);
3014                         update_smart_learn(m_idx, DRS_NETH);
3015                         update_smart_learn(m_idx, DRS_REFLECT);
3016                         break;
3017                 }
3018
3019                 /* RF5_BO_WATE */
3020                 case 128+22:
3021                 {
3022                         if (x!=px || y!=py) return (FALSE);
3023                         disturb(1, 0);
3024 #ifdef JP
3025 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3026 #else
3027                         if (blind) msg_format("%^s mumbles.", m_name);
3028 #endif
3029
3030 #ifdef JP
3031 else msg_format("%^s¤¬¥¦¥©¡¼¥¿¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3032 #else
3033                         else msg_format("%^s casts a water bolt.", m_name);
3034 #endif
3035
3036                         dam = damroll(10, 10) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
3037                         bolt(m_idx, GF_WATER, dam, MS_BOLT_WATER, learnable);
3038                         update_smart_learn(m_idx, DRS_REFLECT);
3039                         break;
3040                 }
3041
3042                 /* RF5_BO_MANA */
3043                 case 128+23:
3044                 {
3045                         if (x!=px || y!=py) return (FALSE);
3046                         disturb(1, 0);
3047 #ifdef JP
3048 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3049 #else
3050                         if (blind) msg_format("%^s mumbles.", m_name);
3051 #endif
3052
3053 #ifdef JP
3054 else msg_format("%^s¤¬ËâÎÏ¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3055 #else
3056                         else msg_format("%^s casts a mana bolt.", m_name);
3057 #endif
3058
3059                         dam = randint1(rlev * 7 / 2) + 50;
3060                         bolt(m_idx, GF_MANA, dam, MS_BOLT_MANA, learnable);
3061                         update_smart_learn(m_idx, DRS_REFLECT);
3062                         break;
3063                 }
3064
3065                 /* RF5_BO_PLAS */
3066                 case 128+24:
3067                 {
3068                         if (x!=px || y!=py) return (FALSE);
3069                         disturb(1, 0);
3070 #ifdef JP
3071 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3072 #else
3073                         if (blind) msg_format("%^s mumbles.", m_name);
3074 #endif
3075
3076 #ifdef JP
3077 else msg_format("%^s¤¬¥×¥é¥º¥Þ¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3078 #else
3079                         else msg_format("%^s casts a plasma bolt.", m_name);
3080 #endif
3081
3082                         dam = 10 + damroll(8, 7) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
3083                         bolt(m_idx, GF_PLASMA, dam, MS_BOLT_PLASMA, learnable);
3084                         update_smart_learn(m_idx, DRS_REFLECT);
3085                         break;
3086                 }
3087
3088                 /* RF5_BO_ICEE */
3089                 case 128+25:
3090                 {
3091                         if (x!=px || y!=py) return (FALSE);
3092                         disturb(1, 0);
3093 #ifdef JP
3094 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3095 #else
3096                         if (blind) msg_format("%^s mumbles.", m_name);
3097 #endif
3098
3099 #ifdef JP
3100 else msg_format("%^s¤¬¶Ë´¨¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3101 #else
3102                         else msg_format("%^s casts an ice bolt.", m_name);
3103 #endif
3104
3105                         dam = damroll(6, 6) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
3106                         bolt(m_idx, GF_ICE, dam, MS_BOLT_ICE, learnable);
3107                         update_smart_learn(m_idx, DRS_COLD);
3108                         update_smart_learn(m_idx, DRS_REFLECT);
3109                         break;
3110                 }
3111
3112                 /* RF5_MISSILE */
3113                 case 128+26:
3114                 {
3115                         if (x!=px || y!=py) return (FALSE);
3116                         disturb(1, 0);
3117 #ifdef JP
3118 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3119 #else
3120                         if (blind) msg_format("%^s mumbles.", m_name);
3121 #endif
3122
3123 #ifdef JP
3124 else msg_format("%^s¤¬¥Þ¥¸¥Ã¥¯¡¦¥ß¥µ¥¤¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3125 #else
3126                         else msg_format("%^s casts a magic missile.", m_name);
3127 #endif
3128
3129                         dam = damroll(2, 6) + (rlev / 3);
3130                         bolt(m_idx, GF_MISSILE, dam, MS_MAGIC_MISSILE, learnable);
3131                         update_smart_learn(m_idx, DRS_REFLECT);
3132                         break;
3133                 }
3134
3135                 /* RF5_SCARE */
3136                 case 128+27:
3137                 {
3138                         if (x!=px || y!=py) return (FALSE);
3139                         if (!direct) break;
3140                         disturb(1, 0);
3141 #ifdef JP
3142 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¯¤È¡¢¶²¤í¤·¤²¤Ê²»¤¬Ê¹¤³¤¨¤¿¡£", m_name);
3143 #else
3144                         if (blind) msg_format("%^s mumbles, and you hear scary noises.", m_name);
3145 #endif
3146
3147 #ifdef JP
3148 else msg_format("%^s¤¬¶²¤í¤·¤²¤Ê¸¸³Ð¤òºî¤ê½Ð¤·¤¿¡£", m_name);
3149 #else
3150                         else msg_format("%^s casts a fearful illusion.", m_name);
3151 #endif
3152
3153                         if (p_ptr->resist_fear)
3154                         {
3155 #ifdef JP
3156 msg_print("¤·¤«¤·¶²ÉÝ¤Ë¿¯¤µ¤ì¤Ê¤«¤Ã¤¿¡£");
3157 #else
3158                                 msg_print("You refuse to be frightened.");
3159 #endif
3160
3161                         }
3162                         else if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3163                         {
3164 #ifdef JP
3165 msg_print("¤·¤«¤·¶²ÉÝ¤Ë¿¯¤µ¤ì¤Ê¤«¤Ã¤¿¡£");
3166 #else
3167                                 msg_print("You refuse to be frightened.");
3168 #endif
3169
3170                         }
3171                         else
3172                         {
3173                                 (void)set_afraid(p_ptr->afraid + randint0(4) + 4);
3174                         }
3175                         learn_spell(MS_SCARE);
3176                         update_smart_learn(m_idx, DRS_FEAR);
3177                         break;
3178                 }
3179
3180                 /* RF5_BLIND */
3181                 case 128+28:
3182                 {
3183                         if (x!=px || y!=py) return (FALSE);
3184                         if (!direct) break;
3185                         disturb(1, 0);
3186 #ifdef JP
3187 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3188 #else
3189                         if (blind) msg_format("%^s mumbles.", m_name);
3190 #endif
3191
3192 #ifdef JP
3193 else msg_format("%^s¤¬¼öÊ¸¤ò¾§¤¨¤Æ¤¢¤Ê¤¿¤ÎÌÜ¤ò¤¯¤é¤Þ¤·¤¿¡ª", m_name);
3194 #else
3195                         else msg_format("%^s casts a spell, burning your eyes!", m_name);
3196 #endif
3197
3198                         if (p_ptr->resist_blind)
3199                         {
3200 #ifdef JP
3201 msg_print("¤·¤«¤·¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª");
3202 #else
3203                                 msg_print("You are unaffected!");
3204 #endif
3205
3206                         }
3207                         else if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3208                         {
3209 #ifdef JP
3210 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
3211 #else
3212                                 msg_print("You resist the effects!");
3213 #endif
3214
3215                         }
3216                         else
3217                         {
3218                                 (void)set_blind(12 + randint0(4));
3219                         }
3220                         learn_spell(MS_BLIND);
3221                         update_smart_learn(m_idx, DRS_BLIND);
3222                         break;
3223                 }
3224
3225                 /* RF5_CONF */
3226                 case 128+29:
3227                 {
3228                         if (x!=px || y!=py) return (FALSE);
3229                         if (!direct) break;
3230                         disturb(1, 0);
3231 #ifdef JP
3232 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¯¤È¡¢Æ¬¤òÇº¤Þ¤¹²»¤¬¤·¤¿¡£", m_name);
3233 #else
3234                         if (blind) msg_format("%^s mumbles, and you hear puzzling noises.", m_name);
3235 #endif
3236
3237 #ifdef JP
3238 else msg_format("%^s¤¬Í¶ÏÇÅª¤Ê¸¸³Ð¤òºî¤ê½Ð¤·¤¿¡£", m_name);
3239 #else
3240                         else msg_format("%^s creates a mesmerising illusion.", m_name);
3241 #endif
3242
3243                         if (p_ptr->resist_conf)
3244                         {
3245 #ifdef JP
3246 msg_print("¤·¤«¤·¸¸³Ð¤Ë¤Ï¤À¤Þ¤µ¤ì¤Ê¤«¤Ã¤¿¡£");
3247 #else
3248                                 msg_print("You disbelieve the feeble spell.");
3249 #endif
3250
3251                         }
3252                         else if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3253                         {
3254 #ifdef JP
3255 msg_print("¤·¤«¤·¸¸³Ð¤Ë¤Ï¤À¤Þ¤µ¤ì¤Ê¤«¤Ã¤¿¡£");
3256 #else
3257                                 msg_print("You disbelieve the feeble spell.");
3258 #endif
3259
3260                         }
3261                         else
3262                         {
3263                                 (void)set_confused(p_ptr->confused + randint0(4) + 4);
3264                         }
3265                         learn_spell(MS_CONF);
3266                         update_smart_learn(m_idx, DRS_CONF);
3267                         break;
3268                 }
3269
3270                 /* RF5_SLOW */
3271                 case 128+30:
3272                 {
3273                         if (x!=px || y!=py) return (FALSE);
3274                         if (!direct) break;
3275                         disturb(1, 0);
3276 #ifdef JP
3277 msg_format("%^s¤¬¤¢¤Ê¤¿¤Î¶ÚÎÏ¤òµÛ¤¤¼è¤í¤¦¤È¤·¤¿¡ª", m_name);
3278 #else
3279                         msg_format("%^s drains power from your muscles!", m_name);
3280 #endif
3281
3282                         if (p_ptr->free_act)
3283                         {
3284 #ifdef JP
3285 msg_print("¤·¤«¤·¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª");
3286 #else
3287                                 msg_print("You are unaffected!");
3288 #endif
3289
3290                         }
3291                         else if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3292                         {
3293 #ifdef JP
3294 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
3295 #else
3296                                 msg_print("You resist the effects!");
3297 #endif
3298
3299                         }
3300                         else
3301                         {
3302                                 (void)set_slow(p_ptr->slow + randint0(4) + 4, FALSE);
3303                         }
3304                         learn_spell(MS_SLOW);
3305                         update_smart_learn(m_idx, DRS_FREE);
3306                         break;
3307                 }
3308
3309                 /* RF5_HOLD */
3310                 case 128+31:
3311                 {
3312                         if (x!=px || y!=py) return (FALSE);
3313                         if (!direct) break;
3314                         disturb(1, 0);
3315 #ifdef JP
3316 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3317 #else
3318                         if (blind) msg_format("%^s mumbles.", m_name);
3319 #endif
3320
3321 #ifdef JP
3322 else msg_format("%^s¤¬¤¢¤Ê¤¿¤ÎÌÜ¤ò¤¸¤Ã¤È¸«¤Ä¤á¤¿¡ª", m_name);
3323 #else
3324                         else msg_format("%^s stares deep into your eyes!", m_name);
3325 #endif
3326
3327                         if (p_ptr->free_act)
3328                         {
3329 #ifdef JP
3330 msg_print("¤·¤«¤·¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª");
3331 #else
3332                                 msg_print("You are unaffected!");
3333 #endif
3334
3335                         }
3336                         else if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3337                         {
3338 #ifdef JP
3339 msg_format("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
3340 #else
3341                                 msg_format("You resist the effects!");
3342 #endif
3343
3344                         }
3345                         else
3346                         {
3347                                 (void)set_paralyzed(p_ptr->paralyzed + randint0(4) + 4);
3348                         }
3349                         learn_spell(MS_SLEEP);
3350                         update_smart_learn(m_idx, DRS_FREE);
3351                         break;
3352                 }
3353
3354                 /* RF6_HASTE */
3355                 case 160+0:
3356                 {
3357                         disturb(1, 0);
3358                         if (blind)
3359                         {
3360 #ifdef JP
3361 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3362 #else
3363                                 msg_format("%^s mumbles.", m_name);
3364 #endif
3365
3366                         }
3367                         else
3368                         {
3369 #ifdef JP
3370 msg_format("%^s¤¬¼«Ê¬¤ÎÂÎ¤ËÇ°¤òÁ÷¤Ã¤¿¡£", m_name, m_poss);
3371 #else
3372                                 msg_format("%^s concentrates on %s body.", m_name, m_poss);
3373 #endif
3374
3375                         }
3376
3377                         /* Allow quick speed increases to base+10 */
3378                         if (!m_ptr->fast)
3379                         {
3380 #ifdef JP
3381 msg_format("%^s¤ÎÆ°¤¤¬Â®¤¯¤Ê¤Ã¤¿¡£", m_name);
3382 #else
3383                                 msg_format("%^s starts moving faster.", m_name);
3384 #endif
3385                         }
3386                         m_ptr->fast = MIN(200, m_ptr->fast + 100);
3387                         if (p_ptr->riding == m_idx) p_ptr->update |= PU_BONUS;
3388                         break;
3389                 }
3390
3391                 /* RF6_HAND_DOOM */
3392                 case 160+1:
3393                 {
3394                         if (x!=px || y!=py) return (FALSE);
3395                         disturb(1, 0);
3396 #ifdef JP
3397 msg_format("%^s¤¬ÇËÌÇ¤Î¼ê¤òÊü¤Ã¤¿¡ª", m_name);
3398 #else
3399                         msg_format("%^s invokes the Hand of Doom!", m_name);
3400 #endif
3401
3402                         if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3403                         {
3404 #ifdef JP
3405 msg_format("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
3406 #else
3407                                 msg_format("You resist the effects!");
3408 #endif
3409                                 learn_spell(MS_HAND_DOOM);
3410
3411                         }
3412                         else
3413                         {
3414                                 int dummy = (((s32b) ((40 + randint1(20)) * (p_ptr->chp))) / 100);
3415 #ifdef JP
3416 msg_print("¤¢¤Ê¤¿¤ÏÌ¿¤¬Çö¤Þ¤Ã¤Æ¤¤¤¯¤è¤¦¤Ë´¶¤¸¤¿¡ª");
3417 #else
3418                                 msg_print("Your feel your life fade away!");
3419 #endif
3420
3421                                 take_hit(DAMAGE_ATTACK, dummy, m_name, MS_HAND_DOOM);
3422                                 curse_equipment(40, 20);
3423
3424                                 if (p_ptr->chp < 1) p_ptr->chp = 1;
3425                         }
3426                         break;
3427                 }
3428
3429                 /* RF6_HEAL */
3430                 case 160+2:
3431                 {
3432                         disturb(1, 0);
3433
3434                         /* Message */
3435                         if (blind)
3436                         {
3437 #ifdef JP
3438 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3439 #else
3440                                 msg_format("%^s mumbles.", m_name);
3441 #endif
3442
3443                         }
3444                         else
3445                         {
3446 #ifdef JP
3447 msg_format("%^s¤¬¼«Ê¬¤Î½ý¤Ë½¸Ãæ¤·¤¿¡£", m_name);
3448 #else
3449                                 msg_format("%^s concentrates on %s wounds.", m_name, m_poss);
3450 #endif
3451
3452                         }
3453
3454                         /* Heal some */
3455                         m_ptr->hp += (rlev * 6);
3456
3457                         /* Fully healed */
3458                         if (m_ptr->hp >= m_ptr->maxhp)
3459                         {
3460                                 /* Fully healed */
3461                                 m_ptr->hp = m_ptr->maxhp;
3462
3463                                 /* Message */
3464                                 if (seen)
3465                                 {
3466 #ifdef JP
3467 msg_format("%^s¤Ï´°Á´¤Ë¼£¤Ã¤¿¡ª", m_name);
3468 #else
3469                                         msg_format("%^s looks completely healed!", m_name);
3470 #endif
3471
3472                                 }
3473                                 else
3474                                 {
3475 #ifdef JP
3476 msg_format("%^s¤Ï´°Á´¤Ë¼£¤Ã¤¿¤è¤¦¤À¡ª", m_name);
3477 #else
3478                                         msg_format("%^s sounds completely healed!", m_name);
3479 #endif
3480
3481                                 }
3482                         }
3483
3484                         /* Partially healed */
3485                         else
3486                         {
3487                                 /* Message */
3488                                 if (seen)
3489                                 {
3490 #ifdef JP
3491 msg_format("%^s¤ÏÂÎÎÏ¤ò²óÉü¤·¤¿¤è¤¦¤À¡£", m_name);
3492 #else
3493                                         msg_format("%^s looks healthier.", m_name);
3494 #endif
3495
3496                                 }
3497                                 else
3498                                 {
3499 #ifdef JP
3500 msg_format("%^s¤ÏÂÎÎÏ¤ò²óÉü¤·¤¿¤è¤¦¤À¡£", m_name);
3501 #else
3502                                         msg_format("%^s sounds healthier.", m_name);
3503 #endif
3504
3505                                 }
3506                         }
3507
3508                         /* Redraw (later) if needed */
3509                         if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
3510                         if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
3511
3512                         /* Cancel fear */
3513                         if (m_ptr->monfear)
3514                         {
3515                                 /* Cancel fear */
3516                                 m_ptr->monfear = 0;
3517
3518                                 /* Message */
3519 #ifdef JP
3520 msg_format("%^s¤ÏÍ¦µ¤¤ò¼è¤êÌá¤·¤¿¡£", m_name, m_poss);
3521 #else
3522                                 msg_format("%^s recovers %s courage.", m_name, m_poss);
3523 #endif
3524
3525                         }
3526                         break;
3527                 }
3528
3529                 /* RF6_INVULNER */
3530                 case 160+3:
3531                 {
3532                         disturb(1, 0);
3533
3534                         /* Message */
3535                         if (!seen)
3536                         {
3537 #ifdef JP
3538 msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3539 #else
3540                                 msg_format("%^s mumbles powerfully.", m_name);
3541 #endif
3542
3543                         }
3544                         else
3545                         {
3546 #ifdef JP
3547 msg_format("%s¤ÏÌµ½ý¤Îµå¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3548 #else
3549                                 msg_format("%^s casts a Globe of Invulnerability.", m_name);
3550 #endif
3551
3552                         }
3553
3554                         if (!(m_ptr->invulner))
3555                                 m_ptr->invulner = randint1(4) + 4;
3556
3557                         if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
3558                         if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
3559                         break;
3560                 }
3561
3562                 /* RF6_BLINK */
3563                 case 160+4:
3564                 {
3565                         disturb(1, 0);
3566 #ifdef JP
3567 msg_format("%^s¤¬½Ö»þ¤Ë¾Ã¤¨¤¿¡£", m_name);
3568 #else
3569                         msg_format("%^s blinks away.", m_name);
3570 #endif
3571
3572                         teleport_away(m_idx, 10, FALSE);
3573                         p_ptr->update |= (PU_MONSTERS | PU_MON_LITE);
3574                         break;
3575                 }
3576
3577                 /* RF6_TPORT */
3578                 case 160+5:
3579                 {
3580                         int i, oldfy, oldfx;
3581                         u32b f1 = 0 , f2 = 0 , f3 = 0;
3582                         object_type *o_ptr;
3583
3584                         oldfy = m_ptr->fy;
3585                         oldfx = m_ptr->fx;
3586
3587                         disturb(1, 0);
3588 #ifdef JP
3589 msg_format("%^s¤¬¥Æ¥ì¥Ý¡¼¥È¤·¤¿¡£", m_name);
3590 #else
3591                         msg_format("%^s teleports away.", m_name);
3592 #endif
3593
3594                         teleport_away(m_idx, MAX_SIGHT * 2 + 5, FALSE);
3595
3596                         if (los(py, px, oldfy, oldfx) && !world_monster)
3597                         {
3598                                 for (i=INVEN_RARM;i<INVEN_TOTAL;i++)
3599                                 {
3600                                         o_ptr = &inventory[i];
3601                                         if(!cursed_p(o_ptr))
3602                                         {
3603                                                 object_flags(o_ptr, &f1, &f2, &f3);
3604
3605                                                 if((f3 & TR3_TELEPORT) || (p_ptr->muta1 & MUT1_VTELEPORT) || (p_ptr->pclass == CLASS_IMITATOR))
3606                                                 {
3607 #ifdef JP
3608                                                         if(get_check_strict("¤Ä¤¤¤Æ¤¤¤¤Þ¤¹¤«¡©", CHECK_OKAY_CANCEL))
3609 #else
3610                                                         if(get_check_strict("Do you follow it? ", CHECK_OKAY_CANCEL))
3611 #endif
3612                                                         {
3613                                                                 if (one_in_(3))
3614                                                                 {
3615                                                                         teleport_player(200);
3616 #ifdef JP
3617                                                                         msg_print("¼ºÇÔ¡ª");
3618 #else
3619                                                                         msg_print("Failed!");
3620 #endif
3621                                                                 }
3622                                                                 else teleport_player_to(m_ptr->fy, m_ptr->fx, TRUE);
3623                                                                 p_ptr->energy_need += ENERGY_NEED();
3624                                                         }
3625                                                         break;
3626                                                 }
3627                                         }
3628                                 }
3629                         }
3630                         break;
3631                 }
3632
3633                 /* RF6_WORLD */
3634                 case 160+6:
3635                 {
3636                         int who = 0;
3637                         disturb(1, 0);
3638                         if(m_ptr->r_idx == MON_DIO) who = 1;
3639                         else if(m_ptr->r_idx == MON_WONG) who = 3;
3640                         dam = who;
3641                         if (!process_the_world(randint1(2)+2, who, TRUE)) return (FALSE);
3642                         break;
3643                 }
3644
3645                 /* RF6_SPECIAL */
3646                 case 160+7:
3647                 {
3648                         int k;
3649
3650                         disturb(1, 0);
3651                         switch(m_ptr->r_idx)
3652                         {
3653                         case MON_OHMU:
3654                                 if (p_ptr->inside_arena || p_ptr->inside_battle) return FALSE;
3655                                 for (k = 0; k < 6; k++)
3656                                 {
3657                                         count += summon_specific(m_idx, m_ptr->fy, m_ptr->fx, rlev, SUMMON_BIZARRE1, PM_ALLOW_GROUP);
3658                                 }
3659                                 return FALSE;
3660
3661                         case MON_BANORLUPART:
3662                                 {
3663                                         int dummy_hp = (m_ptr->hp + 1) / 2;
3664                                         int dummy_maxhp = m_ptr->maxhp/2;
3665                                         int dummy_y = m_ptr->fy;
3666                                         int dummy_x = m_ptr->fx;
3667
3668                                         if (p_ptr->inside_arena || p_ptr->inside_battle || !summon_possible(m_ptr->fy, m_ptr->fx)) return FALSE;
3669                                         delete_monster_idx(cave[m_ptr->fy][m_ptr->fx].m_idx);
3670                                         summon_named_creature(0, dummy_y, dummy_x, MON_BANOR, mode);
3671                                         m_list[hack_m_idx_ii].hp = dummy_hp;
3672                                         m_list[hack_m_idx_ii].maxhp = dummy_maxhp;
3673                                         summon_named_creature(0, dummy_y, dummy_x, MON_LUPART, mode);
3674                                         m_list[hack_m_idx_ii].hp = dummy_hp;
3675                                         m_list[hack_m_idx_ii].maxhp = dummy_maxhp;
3676
3677 #ifdef JP
3678                                         msg_print("¡Ø¥Ð¡¼¥Î¡¼¥ë¡¦¥ë¥Ñ¡¼¥È¡Ù¤¬Ê¬Îö¤·¤¿¡ª");
3679 #else
3680                                         msg_print("Banor=Rupart splits in two person!");
3681 #endif
3682
3683                                         break;
3684                                 }
3685                                 case MON_BANOR:
3686                                 case MON_LUPART:
3687                                 {
3688                                         int dummy_hp = 0;
3689                                         int dummy_maxhp = 0;
3690                                         int dummy_y = m_ptr->fy;
3691                                         int dummy_x = m_ptr->fx;
3692
3693                                         if (!r_info[MON_BANOR].cur_num || !r_info[MON_LUPART].cur_num) return (FALSE);
3694                                         for (k = 1; k < m_max; k++)
3695                                         {
3696                                                 if (m_list[k].r_idx == MON_BANOR || m_list[k].r_idx == MON_LUPART)
3697                                                 {
3698                                                         dummy_hp += m_list[k].hp;
3699                                                         dummy_maxhp += m_list[k].maxhp;
3700                                                         if (m_list[k].r_idx != m_ptr->r_idx)
3701                                                         {
3702                                                                 dummy_y = m_list[k].fy;
3703                                                                 dummy_x = m_list[k].fx;
3704                                                         }
3705                                                         delete_monster_idx(k);
3706                                                 }
3707                                         }
3708                                         summon_named_creature(0, dummy_y, dummy_x, MON_BANORLUPART, mode);
3709                                         m_list[hack_m_idx_ii].hp = dummy_hp;
3710                                         m_list[hack_m_idx_ii].maxhp = dummy_maxhp;
3711
3712 #ifdef JP
3713                                         msg_print("¡Ø¥Ð¡¼¥Î¡¼¥ë¡Ù¤È¡Ø¥ë¥Ñ¡¼¥È¡Ù¤¬¹çÂÎ¤·¤¿¡ª");
3714 #else
3715                                         msg_print("Banor and Rupart combine into one!");
3716 #endif
3717
3718                                         break;
3719                                 }
3720                                 default: return FALSE;
3721                         }
3722                         break;
3723                 }
3724
3725                 /* RF6_TELE_TO */
3726                 case 160+8:
3727                 {
3728                         if (x!=px || y!=py) return (FALSE);
3729                         if (!direct) break;
3730                         disturb(1, 0);
3731 #ifdef JP
3732 msg_format("%^s¤¬¤¢¤Ê¤¿¤ò°ú¤Ìá¤·¤¿¡£", m_name);
3733 #else
3734                         msg_format("%^s commands you to return.", m_name);
3735 #endif
3736
3737                         teleport_player_to(m_ptr->fy, m_ptr->fx, TRUE);
3738                         learn_spell(MS_TELE_TO);
3739                         break;
3740                 }
3741
3742                 /* RF6_TELE_AWAY */
3743                 case 160+9:
3744                 {
3745                         if (x!=px || y!=py) return (FALSE);
3746                         if (!direct) break;
3747                         disturb(1, 0);
3748 #ifdef JP
3749 msg_format("%^s¤Ë¥Æ¥ì¥Ý¡¼¥È¤µ¤»¤é¤ì¤¿¡£", m_name);
3750                         if ((p_ptr->pseikaku == SEIKAKU_COMBAT) || (inventory[INVEN_BOW].name1 == ART_CRIMSON))
3751                                 msg_print("¤¯¤Ã¤½¡Á");
3752 #else
3753                         msg_format("%^s teleports you away.", m_name);
3754 #endif
3755
3756                         learn_spell(MS_TELE_AWAY);
3757                         teleport_player(100);
3758                         break;
3759                 }
3760
3761                 /* RF6_TELE_LEVEL */
3762                 case 160+10:
3763                 {
3764                         if (x!=px || y!=py) return (FALSE);
3765                         if (!direct) break;
3766                         disturb(1, 0);
3767 #ifdef JP
3768 if (blind) msg_format("%^s¤¬²¿¤«´ñÌ¯¤Ê¸ÀÍÕ¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3769 #else
3770                         if (blind) msg_format("%^s mumbles strangely.", m_name);
3771 #endif
3772
3773 #ifdef JP
3774 else msg_format("%^s¤¬¤¢¤Ê¤¿¤ÎÂ¤ò»Ø¤µ¤·¤¿¡£", m_name);
3775 #else
3776                         else msg_format("%^s gestures at your feet.", m_name);
3777 #endif
3778
3779                         if (p_ptr->resist_nexus)
3780                         {
3781 #ifdef JP
3782 msg_print("¤·¤«¤·¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª");
3783 #else
3784                                 msg_print("You are unaffected!");
3785 #endif
3786
3787                         }
3788                         else if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3789                         {
3790 #ifdef JP
3791 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
3792 #else
3793                                 msg_print("You resist the effects!");
3794 #endif
3795
3796                         }
3797                         else
3798                         {
3799                                 teleport_player_level();
3800                         }
3801                         learn_spell(MS_TELE_LEVEL);
3802                         update_smart_learn(m_idx, DRS_NEXUS);
3803                         break;
3804                 }
3805
3806                 /* RF6_PSY_SPEAR */
3807                 case 160+11:
3808                 {
3809                         if (x!=px || y!=py) return (FALSE);
3810                         disturb(1, 0);
3811 #ifdef JP
3812 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3813 #else
3814                         if (blind) msg_format("%^s mumbles.", m_name);
3815 #endif
3816
3817 #ifdef JP
3818 else msg_format("%^s¤¬¸÷¤Î·õ¤òÊü¤Ã¤¿¡£", m_name);
3819 #else
3820                         else msg_format("%^s throw a Psycho-Spear.", m_name);
3821 #endif
3822
3823                         dam = (r_ptr->flags2 & RF2_POWERFUL) ? (randint1(rlev * 2) + 150) : (randint1(rlev * 3 / 2) + 100);
3824                         beam(m_idx, GF_PSY_SPEAR, dam, MS_PSY_SPEAR, learnable);
3825                         break;
3826                 }
3827
3828                 /* RF6_DARKNESS */
3829                 case 160+12:
3830                 {
3831                         if (x!=px || y!=py) return (FALSE);
3832                         if (!direct) break;
3833                         disturb(1, 0);
3834 #ifdef JP
3835 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3836 #else
3837                         if (blind) msg_format("%^s mumbles.", m_name);
3838 #endif
3839
3840 #ifdef JP
3841 else if (p_ptr->pclass == CLASS_NINJA) msg_format("%^s¤¬ÊÕ¤ê¤òÌÀ¤ë¤¯¾È¤é¤·¤¿¡£", m_name);
3842 else msg_format("%^s¤¬°Å°Ç¤ÎÃæ¤Ç¼ê¤ò¿¶¤Ã¤¿¡£", m_name);
3843 #else
3844                         else if (p_ptr->pclass == CLASS_NINJA)
3845                                 msg_format("%^s cast a spell to light up.", m_name);
3846                         else msg_format("%^s gestures in shadow.", m_name);
3847 #endif
3848
3849                         learn_spell(MS_DARKNESS);
3850                         if (p_ptr->pclass == CLASS_NINJA)
3851                                 (void)lite_area(0, 3);
3852                         else
3853                                 (void)unlite_area(0, 3);
3854                         break;
3855                 }
3856
3857                 /* RF6_TRAPS */
3858                 case 160+13:
3859                 {
3860                         if (!direct) break;
3861                         disturb(1, 0);
3862 #ifdef JP
3863 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤Æ¼Ù°¤ËÈù¾Ð¤ó¤À¡£", m_name);
3864 #else
3865                         if (blind) msg_format("%^s mumbles, and then cackles evilly.", m_name);
3866 #endif
3867
3868 #ifdef JP
3869 else msg_format("%^s¤¬¼öÊ¸¤ò¾§¤¨¤Æ¼Ù°¤ËÈù¾Ð¤ó¤À¡£", m_name);
3870 #else
3871                         else msg_format("%^s casts a spell and cackles evilly.", m_name);
3872 #endif
3873
3874                         learn_spell(MS_MAKE_TRAP);
3875                         (void)trap_creation(y, x);
3876                         break;
3877                 }
3878
3879                 /* RF6_FORGET */
3880                 case 160+14:
3881                 {
3882                         if (x!=px || y!=py) return (FALSE);
3883                         if (!direct) break;
3884                         disturb(1, 0);
3885 #ifdef JP
3886 msg_format("%^s¤¬¤¢¤Ê¤¿¤Îµ²±¤ò¾Ãµî¤·¤è¤¦¤È¤·¤Æ¤¤¤ë¡£", m_name);
3887 #else
3888                         msg_format("%^s tries to blank your mind.", m_name);
3889 #endif
3890
3891
3892                         if (randint0(100 + rlev/2) < p_ptr->skill_sav)
3893                         {
3894 #ifdef JP
3895 msg_print("¤·¤«¤·¸úÎÏ¤òÄ·¤ÍÊÖ¤·¤¿¡ª");
3896 #else
3897                                 msg_print("You resist the effects!");
3898 #endif
3899
3900                         }
3901                         else if (lose_all_info())
3902                         {
3903 #ifdef JP
3904 msg_print("µ²±¤¬Çö¤ì¤Æ¤·¤Þ¤Ã¤¿¡£");
3905 #else
3906                                 msg_print("Your memories fade away.");
3907 #endif
3908
3909                         }
3910                         learn_spell(MS_FORGET);
3911                         break;
3912                 }
3913
3914                 /* RF6_RAISE_DEAD */
3915                 case 160+15:
3916                 {
3917                         disturb(1, 0);
3918 #ifdef JP
3919 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3920 #else
3921                         if (blind) msg_format("%^s mumbles.", m_name);
3922 #endif
3923
3924 #ifdef JP
3925 else msg_format("%^s¤¬»à¼ÔÉü³è¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3926 #else
3927                         else msg_format("%^s casts a spell to revive corpses.", m_name);
3928 #endif
3929                         animate_dead(m_idx, m_ptr->fy, m_ptr->fx);
3930                         break;
3931                 }
3932
3933                 /* RF6_SUMMON_KIN */
3934                 case 160+16:
3935                 {
3936                         disturb(1, 0);
3937                         if (m_ptr->r_idx == MON_ROLENTO)
3938                         {
3939 #ifdef JP
3940                                 if (blind)
3941                                         msg_format("%^s¤¬²¿¤«ÂçÎÌ¤ËÅê¤²¤¿¡£", m_name);
3942                                 else
3943                                         msg_format("%^s¤Ï¼êÜØÃÆ¤ò¤Ð¤é¤Þ¤¤¤¿¡£", m_name);
3944 #else
3945                                 if (blind)
3946                                         msg_format("%^s spreads something.", m_name);
3947                                 else
3948                                         msg_format("%^s throws some hand grenades.", m_name);
3949 #endif
3950                         }
3951                         else if (m_ptr->r_idx == MON_SERPENT || m_ptr->r_idx == MON_ZOMBI_SERPENT)
3952                         {
3953 #ifdef JP
3954                                 if (blind)
3955                                         msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3956                                 else
3957                                         msg_format("%^s¤¬¥À¥ó¥¸¥ç¥ó¤Î¼ç¤ò¾¤´¤·¤¿¡£", m_name);
3958 #else
3959                                 if (blind)
3960                                         msg_format("%^s mumbles.", m_name);
3961                                 else
3962                                         msg_format("%^s magically summons guardians of dungeons.", m_name);
3963 #endif
3964                         }
3965                         else
3966                         {
3967 #ifdef JP
3968                                 if (blind)
3969                                         msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3970                                 else
3971                                         msg_format("%^s¤ÏËâË¡¤Ç%s¤ò¾¤´¤·¤¿¡£",
3972                                         m_name,
3973                                         ((r_ptr->flags1) & RF1_UNIQUE ?
3974                                         "¼ê²¼" : "Ãç´Ö"));
3975 #else
3976                                 if (blind)
3977                                         msg_format("%^s mumbles.", m_name);
3978                                 else
3979                                         msg_format("%^s magically summons %s %s.",
3980                                         m_name, m_poss,
3981                                         ((r_ptr->flags1) & RF1_UNIQUE ?
3982                                         "minions" : "kin"));
3983 #endif
3984                         }
3985
3986                         if(m_ptr->r_idx == MON_ROLENTO)
3987                         {
3988                                 int num = 1 + randint1(3);
3989
3990                                 for (k = 0; k < num; k++)
3991                                 {
3992                                         count += summon_named_creature(m_idx, y, x, MON_SHURYUUDAN, mode);
3993                                 }
3994                         }
3995                         else if(m_ptr->r_idx == MON_LOUSY)
3996                         {
3997                                 int num = 2 + randint1(3);
3998                                 for (k = 0; k < num; k++)
3999                                 {
4000                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_LOUSE, PM_ALLOW_GROUP);
4001                                 }
4002                         }
4003                         else if(m_ptr->r_idx == MON_BULLGATES)
4004                         {
4005                                 int num = 2 + randint1(3);
4006                                 for (k = 0; k < num; k++)
4007                                 {
4008                                         count += summon_named_creature(m_idx, y, x, 921, mode);
4009                                 }
4010                         }
4011                         else if (m_ptr->r_idx == MON_CALDARM)
4012                         {
4013                                 int num = randint1(3);
4014                                 for (k = 0; k < num; k++)
4015                                 {
4016                                         count += summon_named_creature(m_idx, y, x, 930, mode);
4017                                 }
4018                         }
4019                         else if (m_ptr->r_idx == MON_SERPENT || m_ptr->r_idx == MON_ZOMBI_SERPENT)
4020                         {
4021                                 int num = 2 + randint1(3);
4022
4023                                 if (r_info[MON_JORMUNGAND].cur_num < r_info[MON_JORMUNGAND].max_num && one_in_(6))
4024                                 {
4025 #ifdef JP
4026                                         msg_print("ÃÏÌÌ¤«¤é¿å¤¬¿á¤½Ð¤·¤¿¡ª");
4027 #else
4028                                         msg_print("Water blew off from the ground!");
4029 #endif
4030                                         fire_ball_hide(GF_WATER_FLOW, 0, 3, 8);
4031                                 }
4032
4033                                 for (k = 0; k < num; k++)
4034                                 {
4035                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_GUARDIANS, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4036                                 }
4037                         }
4038                         else
4039                         {
4040
4041                                 summon_kin_type = r_ptr->d_char; /* Big hack */
4042
4043                                 for (k = 0; k < 4; k++)
4044                                 {
4045                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_KIN, PM_ALLOW_GROUP);
4046                                 }
4047                         }
4048 #ifdef JP
4049 if (blind && count) msg_print("Â¿¤¯¤Î¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4050 #else
4051                         if (blind && count) msg_print("You hear many things appear nearby.");
4052 #endif
4053
4054
4055                         break;
4056                 }
4057
4058                 /* RF6_S_CYBER */
4059                 case 160+17:
4060                 {
4061                         disturb(1, 0);
4062 #ifdef JP
4063 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4064 #else
4065                         if (blind) msg_format("%^s mumbles.", m_name);
4066 #endif
4067
4068 #ifdef JP
4069 else msg_format("%^s¤¬¥µ¥¤¥Ð¡¼¥Ç¡¼¥â¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
4070 #else
4071                         else msg_format("%^s magically summons Cyberdemons!", m_name);
4072 #endif
4073
4074 #ifdef JP
4075 if (blind && count) msg_print("½Å¸ü¤ÊÂ²»¤¬¶á¤¯¤ÇÊ¹¤³¤¨¤ë¡£");
4076 #else
4077                         if (blind && count) msg_print("You hear heavy steps nearby.");
4078 #endif
4079
4080                         summon_cyber(m_idx, y, x);
4081                         break;
4082                 }
4083
4084                 /* RF6_S_MONSTER */
4085                 case 160+18:
4086                 {
4087                         disturb(1, 0);
4088 #ifdef JP
4089 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4090 #else
4091                         if (blind) msg_format("%^s mumbles.", m_name);
4092 #endif
4093
4094 #ifdef JP
4095 else msg_format("%^s¤¬ËâË¡¤ÇÃç´Ö¤ò¾¤´¤·¤¿¡ª", m_name);
4096 #else
4097                         else msg_format("%^s magically summons help!", m_name);
4098 #endif
4099
4100                         for (k = 0; k < 1; k++)
4101                         {
4102                                 count += summon_specific(m_idx, y, x, rlev, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4103                         }
4104 #ifdef JP
4105 if (blind && count) msg_print("²¿¤«¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4106 #else
4107                         if (blind && count) msg_print("You hear something appear nearby.");
4108 #endif
4109
4110                         break;
4111                 }
4112
4113                 /* RF6_S_MONSTERS */
4114                 case 160+19:
4115                 {
4116                         disturb(1, 0);
4117 #ifdef JP
4118 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4119 #else
4120                         if (blind) msg_format("%^s mumbles.", m_name);
4121 #endif
4122
4123 #ifdef JP
4124 else msg_format("%^s¤¬ËâË¡¤Ç¥â¥ó¥¹¥¿¡¼¤ò¾¤´¤·¤¿¡ª", m_name);
4125 #else
4126                         else msg_format("%^s magically summons monsters!", m_name);
4127 #endif
4128
4129                         for (k = 0; k < s_num_6; k++)
4130                         {
4131                                 count += summon_specific(m_idx, y, x, rlev, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4132                         }
4133 #ifdef JP
4134 if (blind && count) msg_print("Â¿¤¯¤Î¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4135 #else
4136                         if (blind && count) msg_print("You hear many things appear nearby.");
4137 #endif
4138
4139                         break;
4140                 }
4141
4142                 /* RF6_S_ANT */
4143                 case 160+20:
4144                 {
4145                         disturb(1, 0);
4146 #ifdef JP
4147 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4148 #else
4149                         if (blind) msg_format("%^s mumbles.", m_name);
4150 #endif
4151
4152 #ifdef JP
4153 else msg_format("%^s¤¬ËâË¡¤Ç¥¢¥ê¤ò¾¤´¤·¤¿¡£", m_name);
4154 #else
4155                         else msg_format("%^s magically summons ants.", m_name);
4156 #endif
4157
4158                         for (k = 0; k < s_num_6; k++)
4159                         {
4160                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_ANT, PM_ALLOW_GROUP);
4161                         }
4162 #ifdef JP
4163 if (blind && count) msg_print("Â¿¤¯¤Î¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4164 #else
4165                         if (blind && count) msg_print("You hear many things appear nearby.");
4166 #endif
4167
4168                         break;
4169                 }
4170
4171                 /* RF6_S_SPIDER */
4172                 case 160+21:
4173                 {
4174                         disturb(1, 0);
4175 #ifdef JP
4176 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4177 #else
4178                         if (blind) msg_format("%^s mumbles.", m_name);
4179 #endif
4180
4181 #ifdef JP
4182 else msg_format("%^s¤¬ËâË¡¤Ç¥¯¥â¤ò¾¤´¤·¤¿¡£", m_name);
4183 #else
4184                         else msg_format("%^s magically summons spiders.", m_name);
4185 #endif
4186
4187                         for (k = 0; k < s_num_6; k++)
4188                         {
4189                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_SPIDER, PM_ALLOW_GROUP);
4190                         }
4191 #ifdef JP
4192 if (blind && count) msg_print("Â¿¤¯¤Î¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4193 #else
4194                         if (blind && count) msg_print("You hear many things appear nearby.");
4195 #endif
4196
4197                         break;
4198                 }
4199
4200                 /* RF6_S_HOUND */
4201                 case 160+22:
4202                 {
4203                         disturb(1, 0);
4204 #ifdef JP
4205 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4206 #else
4207                         if (blind) msg_format("%^s mumbles.", m_name);
4208 #endif
4209
4210 #ifdef JP
4211 else msg_format("%^s¤¬ËâË¡¤Ç¥Ï¥¦¥ó¥É¤ò¾¤´¤·¤¿¡£", m_name);
4212 #else
4213                         else msg_format("%^s magically summons hounds.", m_name);
4214 #endif
4215
4216                         for (k = 0; k < s_num_4; k++)
4217                         {
4218                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_HOUND, PM_ALLOW_GROUP);
4219                         }
4220 #ifdef JP
4221 if (blind && count) msg_print("Â¿¤¯¤Î¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4222 #else
4223                         if (blind && count) msg_print("You hear many things appear nearby.");
4224 #endif
4225
4226                         break;
4227                 }
4228
4229                 /* RF6_S_HYDRA */
4230                 case 160+23:
4231                 {
4232                         disturb(1, 0);
4233 #ifdef JP
4234 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4235 #else
4236                         if (blind) msg_format("%^s mumbles.", m_name);
4237 #endif
4238
4239 #ifdef JP
4240 else msg_format("%^s¤¬ËâË¡¤Ç¥Ò¥É¥é¤ò¾¤´¤·¤¿¡£", m_name);
4241 #else
4242                         else msg_format("%^s magically summons hydras.", m_name);
4243 #endif
4244
4245                         for (k = 0; k < s_num_4; k++)
4246                         {
4247                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_HYDRA, PM_ALLOW_GROUP);
4248                         }
4249 #ifdef JP
4250 if (blind && count) msg_print("Â¿¤¯¤Î¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4251 #else
4252                         if (blind && count) msg_print("You hear many things appear nearby.");
4253 #endif
4254
4255                         break;
4256                 }
4257
4258                 /* RF6_S_ANGEL */
4259                 case 160+24:
4260                 {
4261                         int num = 1;
4262
4263                         disturb(1, 0);
4264 #ifdef JP
4265 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4266 #else
4267                         if (blind) msg_format("%^s mumbles.", m_name);
4268 #endif
4269
4270 #ifdef JP
4271 else msg_format("%^s¤¬ËâË¡¤ÇÅ·»È¤ò¾¤´¤·¤¿¡ª", m_name);
4272 #else
4273                         else msg_format("%^s magically summons an angel!", m_name);
4274 #endif
4275
4276                         if ((r_ptr->flags1 & RF1_UNIQUE) && !easy_band)
4277                         {
4278                                 num += r_ptr->level/40;
4279                         }
4280
4281                         for (k = 0; k < num; k++)
4282                         {
4283                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_ANGEL, PM_ALLOW_GROUP);
4284                         }
4285
4286                         if (count < 2)
4287                         {
4288 #ifdef JP
4289 if (blind && count) msg_print("²¿¤«¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4290 #else
4291                                 if (blind && count) msg_print("You hear something appear nearby.");
4292 #endif
4293                         }
4294                         else
4295                         {
4296 #ifdef JP
4297 if (blind) msg_print("Â¿¤¯¤Î¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4298 #else
4299                                 if (blind) msg_print("You hear many things appear nearby.");
4300 #endif
4301                         }
4302
4303                         break;
4304                 }
4305
4306                 /* RF6_S_DEMON */
4307                 case 160+25:
4308                 {
4309                         disturb(1, 0);
4310 #ifdef JP
4311 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4312 #else
4313                         if (blind) msg_format("%^s mumbles.", m_name);
4314 #endif
4315
4316 #ifdef JP
4317 else msg_format("%^s¤ÏËâË¡¤Çº®ÆÙ¤ÎµÜÄî¤«¤é°Ëâ¤ò¾¤´¤·¤¿¡ª", m_name);
4318 #else
4319                         else msg_format("%^s magically summons a demon from the Courts of Chaos!", m_name);
4320 #endif
4321
4322                         for (k = 0; k < 1; k++)
4323                         {
4324                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_DEMON, PM_ALLOW_GROUP);
4325                         }
4326 #ifdef JP
4327 if (blind && count) msg_print("²¿¤«¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4328 #else
4329                         if (blind && count) msg_print("You hear something appear nearby.");
4330 #endif
4331
4332                         break;
4333                 }
4334
4335                 /* RF6_S_UNDEAD */
4336                 case 160+26:
4337                 {
4338                         disturb(1, 0);
4339 #ifdef JP
4340 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4341 #else
4342                         if (blind) msg_format("%^s mumbles.", m_name);
4343 #endif
4344
4345 #ifdef JP
4346 else msg_format("%^s¤¬ËâË¡¤Ç¥¢¥ó¥Ç¥Ã¥É¤Î¶¯Å¨¤ò¾¤´¤·¤¿¡ª", m_name);
4347 #else
4348                         else msg_format("%^s magically summons an undead adversary!", m_name);
4349 #endif
4350
4351                         for (k = 0; k < 1; k++)
4352                         {
4353                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_UNDEAD, PM_ALLOW_GROUP);
4354                         }
4355 #ifdef JP
4356 if (blind && count) msg_print("²¿¤«¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4357 #else
4358                         if (blind && count) msg_print("You hear something appear nearby.");
4359 #endif
4360
4361                         break;
4362                 }
4363
4364                 /* RF6_S_DRAGON */
4365                 case 160+27:
4366                 {
4367                         disturb(1, 0);
4368 #ifdef JP
4369 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4370 #else
4371                         if (blind) msg_format("%^s mumbles.", m_name);
4372 #endif
4373
4374 #ifdef JP
4375 else msg_format("%^s¤¬ËâË¡¤Ç¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
4376 #else
4377                         else msg_format("%^s magically summons a dragon!", m_name);
4378 #endif
4379
4380                         for (k = 0; k < 1; k++)
4381                         {
4382                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_DRAGON, PM_ALLOW_GROUP);
4383                         }
4384 #ifdef JP
4385 if (blind && count) msg_print("²¿¤«¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬¤¹¤ë¡£");
4386 #else
4387                         if (blind && count) msg_print("You hear something appear nearby.");
4388 #endif
4389
4390                         break;
4391                 }
4392
4393                 /* RF6_S_HI_UNDEAD */
4394                 case 160+28:
4395                 {
4396                         disturb(1, 0);
4397
4398                         if (((m_ptr->r_idx == MON_MORGOTH) || (m_ptr->r_idx == MON_SAURON) || (m_ptr->r_idx == MON_ANGMAR)) && ((r_info[MON_NAZGUL].cur_num+2) < r_info[MON_NAZGUL].max_num))
4399                         {
4400                                 int cy = y;
4401                                 int cx = x;
4402
4403 #ifdef JP
4404 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4405 #else
4406                                 if (blind) msg_format("%^s mumbles.", m_name);
4407 #endif
4408
4409 #ifdef JP
4410 else msg_format("%^s¤¬ËâË¡¤ÇÍ©µ´ÀïÂâ¤ò¾¤´¤·¤¿¡ª", m_name);
4411 #else
4412                                 else msg_format("%^s magically summons rangers of Nazgul!", m_name);
4413 #endif
4414                                 msg_print(NULL);
4415
4416                                 for (k = 0; k < 30; k++)
4417                                 {
4418                                         if (!summon_possible(cy, cx) || !cave_floor_bold(cy, cx))
4419                                         {
4420                                                 int j;
4421                                                 for (j = 100; j > 0; j--)
4422                                                 {
4423                                                         scatter(&cy, &cx, y, x, 2, 0);
4424                                                         if (cave_floor_bold(cy, cx)) break;
4425                                                 }
4426                                                 if (!j) break;
4427                                         }
4428                                         if (!cave_floor_bold(cy, cx)) continue;
4429
4430                                         if (summon_named_creature(m_idx, cy, cx, MON_NAZGUL, mode))
4431                                         {
4432                                                 y = cy;
4433                                                 x = cx;
4434                                                 count++;
4435                                                 if (count == 1)
4436 #ifdef JP
4437 msg_format("¡ÖÍ©µ´ÀïÂâ%d¹æ¡¢¥Ê¥º¥°¥ë¡¦¥Ö¥é¥Ã¥¯¡ª¡×", count);
4438 #else
4439                                                         msg_format("A Nazgul says 'Nazgul-Rangers Number %d, Nazgul-Black!'",count);
4440 #endif
4441                                                 else
4442 #ifdef JP
4443 msg_format("¡ÖÆ±¤¸¤¯%d¹æ¡¢¥Ê¥º¥°¥ë¡¦¥Ö¥é¥Ã¥¯¡ª¡×", count);
4444 #else
4445                                                         msg_format("Another one says 'Number %d, Nazgul-Black!'",count);
4446 #endif
4447                                                 msg_print(NULL);
4448                                         }
4449                                 }
4450 #ifdef JP
4451 msg_format("¡Ö%dÉ¤¤½¤í¤Ã¤Æ¡¢¥ê¥ó¥°¥ì¥ó¥¸¥ã¡¼¡ª¡×", count);
4452 #else
4453 msg_format("They say 'The %d meets! We are the Ring-Ranger!'.", count);
4454 #endif
4455                                 msg_print(NULL);
4456                         }
4457                         else
4458                         {
4459 #ifdef JP
4460 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4461 #else
4462                                 if (blind) msg_format("%^s mumbles.", m_name);
4463 #endif
4464
4465 #ifdef JP
4466 else msg_format("%^s¤¬ËâË¡¤Ç¶¯ÎÏ¤Ê¥¢¥ó¥Ç¥Ã¥É¤ò¾¤´¤·¤¿¡ª", m_name);
4467 #else
4468                                 else msg_format("%^s magically summons greater undead!", m_name);
4469 #endif
4470
4471                                 for (k = 0; k < s_num_6; k++)
4472                                 {
4473                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_UNDEAD, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4474                                 }
4475                         }
4476                         if (blind && count)
4477                         {
4478 #ifdef JP
4479 msg_print("´Ö¶á¤Ç²¿¤«Â¿¤¯¤Î¤â¤Î¤¬Çç¤¤²ó¤ë²»¤¬Ê¹¤³¤¨¤ë¡£");
4480 #else
4481                                 msg_print("You hear many creepy things appear nearby.");
4482 #endif
4483
4484                         }
4485                         break;
4486                 }
4487
4488                 /* RF6_S_HI_DRAGON */
4489                 case 160+29:
4490                 {
4491                         disturb(1, 0);
4492 #ifdef JP
4493 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4494 #else
4495                         if (blind) msg_format("%^s mumbles.", m_name);
4496 #endif
4497
4498 #ifdef JP
4499 else msg_format("%^s¤¬ËâË¡¤Ç¸ÅÂå¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
4500 #else
4501                         else msg_format("%^s magically summons ancient dragons!", m_name);
4502 #endif
4503
4504                         for (k = 0; k < s_num_4; k++)
4505                         {
4506                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_DRAGON, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4507                         }
4508                         if (blind && count)
4509                         {
4510 #ifdef JP
4511 msg_print("Â¿¤¯¤ÎÎÏ¶¯¤¤¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬Ê¹¤³¤¨¤ë¡£");
4512 #else
4513                                 msg_print("You hear many powerful things appear nearby.");
4514 #endif
4515
4516                         }
4517                         break;
4518                 }
4519
4520                 /* RF6_S_AMBERITES */
4521                 case 160+30:
4522                 {
4523                         disturb(1, 0);
4524 #ifdef JP
4525 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4526 #else
4527                         if (blind) msg_format("%^s mumbles.", m_name);
4528 #endif
4529
4530 #ifdef JP
4531 else msg_format("%^s¤¬¥¢¥ó¥Ð¡¼¤Î²¦Â²¤ò¾¤´¤·¤¿¡ª", m_name);
4532 #else
4533                         else msg_format("%^s magically summons Lords of Amber!", m_name);
4534 #endif
4535
4536
4537
4538                         for (k = 0; k < s_num_4; k++)
4539                         {
4540                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_AMBERITES, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4541                         }
4542                         if (blind && count)
4543                         {
4544 #ifdef JP
4545 msg_print("ÉÔ»à¤Î¼Ô¤¬¶á¤¯¤Ë¸½¤ì¤ë¤Î¤¬Ê¹¤³¤¨¤¿¡£");
4546 #else
4547                                 msg_print("You hear immortal beings appear nearby.");
4548 #endif
4549
4550                         }
4551                         break;
4552                 }
4553
4554                 /* RF6_S_UNIQUE */
4555                 case 160+31:
4556                 {
4557                         disturb(1, 0);
4558 #ifdef JP
4559 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
4560 #else
4561                         if (blind) msg_format("%^s mumbles.", m_name);
4562 #endif
4563
4564 #ifdef JP
4565 else msg_format("%^s¤¬ËâË¡¤ÇÆÃÊÌ¤Ê¶¯Å¨¤ò¾¤´¤·¤¿¡ª", m_name);
4566 #else
4567                         else msg_format("%^s magically summons special opponents!", m_name);
4568 #endif
4569
4570                         for (k = 0; k < s_num_4; k++)
4571                         {
4572                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_UNIQUE, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4573                         }
4574                         if (r_ptr->flags3 & RF3_GOOD)
4575                         {
4576                                 for (k = count; k < s_num_4; k++)
4577                                 {
4578                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_ANGEL, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4579                                 }
4580                         }
4581                         else
4582                         {
4583                                 for (k = count; k < s_num_4; k++)
4584                                 {
4585                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_UNDEAD, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
4586                                 }
4587                         }
4588                         if (blind && count)
4589                         {
4590 #ifdef JP
4591 msg_print("Â¿¤¯¤ÎÎÏ¶¯¤¤¤â¤Î¤¬´Ö¶á¤Ë¸½¤ì¤¿²»¤¬Ê¹¤³¤¨¤ë¡£");
4592 #else
4593                                 msg_print("You hear many powerful things appear nearby.");
4594 #endif
4595
4596                         }
4597                         break;
4598                 }
4599         }
4600
4601         if ((p_ptr->action == ACTION_LEARN) && thrown_spell > 175)
4602         {
4603                 learn_spell(thrown_spell - 96);
4604         }
4605
4606         if (seen && maneable && !world_monster && (p_ptr->pclass == CLASS_IMITATOR))
4607         {
4608                 if (thrown_spell != 167)
4609                 {
4610                         if (p_ptr->mane_num == MAX_MANE)
4611                         {
4612                                 int i;
4613                                 p_ptr->mane_num--;
4614                                 for (i = 0;i < p_ptr->mane_num;i++)
4615                                 {
4616                                         p_ptr->mane_spell[i] = p_ptr->mane_spell[i+1];
4617                                         p_ptr->mane_dam[i] = p_ptr->mane_dam[i+1];
4618                                 }
4619                         }
4620                         p_ptr->mane_spell[p_ptr->mane_num] = thrown_spell - 96;
4621                         p_ptr->mane_dam[p_ptr->mane_num] = dam;
4622                         p_ptr->mane_num++;
4623                         new_mane = TRUE;
4624
4625                         p_ptr->redraw |= (PR_MANE);
4626                 }
4627         }
4628
4629         /* Remember what the monster did to us */
4630         if (seen)
4631         {
4632                 /* Inate spell */
4633                 if (thrown_spell < 32 * 4)
4634                 {
4635                         r_ptr->r_flags4 |= (1L << (thrown_spell - 32 * 3));
4636                         if (r_ptr->r_cast_inate < MAX_UCHAR) r_ptr->r_cast_inate++;
4637                 }
4638
4639                 /* Bolt or Ball */
4640                 else if (thrown_spell < 32 * 5)
4641                 {
4642                         r_ptr->r_flags5 |= (1L << (thrown_spell - 32 * 4));
4643                         if (r_ptr->r_cast_spell < MAX_UCHAR) r_ptr->r_cast_spell++;
4644                 }
4645
4646                 /* Special spell */
4647                 else if (thrown_spell < 32 * 6)
4648                 {
4649                         r_ptr->r_flags6 |= (1L << (thrown_spell - 32 * 5));
4650                         if (r_ptr->r_cast_spell < MAX_UCHAR) r_ptr->r_cast_spell++;
4651                 }
4652         }
4653
4654
4655         /* Always take note of monsters that kill you */
4656         if (p_ptr->is_dead && (r_ptr->r_deaths < MAX_SHORT) && !p_ptr->inside_arena)
4657         {
4658                 r_ptr->r_deaths++;
4659         }
4660
4661         /* A spell was cast */
4662         return (TRUE);
4663 }