src/mspells1.c

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