src/mspells2.c

   1 /* File: mspells2.c */
   2
   3 /* Purpose: Monster spells (attack monster) */
   4
   5 /*
   6  * Copyright (c) 1989 James E. Wilson, Robert A. Koeneke
   7  *
   8  * This software may be copied and distributed for educational, research, and
   9  * not for profit purposes provided that this copyright and statement are
  10  * included in all such copies.
  11  */
  12
  13 #include "angband.h"
  14
  15
  16 /*
  17  * Monster casts a breath (or ball) attack at another monster.
  18  * Pass over any monsters that may be in the way
  19  * Affect grids, objects, monsters, and the player
  20  */
  21 static void monst_breath_monst(int m_idx, int y, int x, int typ, int dam_hp, int rad, bool breath, int monspell, bool learnable)
  22 {
  23         int flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_MONSTER;
  24
  25         monster_type *m_ptr = &m_list[m_idx];
  26         monster_race *r_ptr = &r_info[m_ptr->r_idx];
  27
  28         /* Determine the radius of the blast */
  29         if (rad < 1 && breath) rad = (r_ptr->flags2 & RF2_POWERFUL) ? 3 : 2;
  30
  31         /* Handle breath attacks */
  32         if (breath) rad = 0 - rad;
  33
  34         if (typ == GF_ROCKET) flg |= PROJECT_STOP;
  35
  36         (void)project(m_idx, rad, y, x, dam_hp, typ, flg, (learnable ? monspell : -1));
  37 }
  38
  39
  40 /*
  41  * Monster casts a bolt at another monster
  42  * Stop if we hit a monster
  43  * Affect monsters and the player
  44  */
  45 static void monst_bolt_monst(int m_idx, int y, int x, int typ, int dam_hp, int monspell, bool learnable)
  46 {
  47         int flg = PROJECT_STOP | PROJECT_KILL | PROJECT_MONSTER | PROJECT_REFLECTABLE;
  48
  49         (void)project(m_idx, 0, y, x, dam_hp, typ, flg, (learnable ? monspell : -1));
  50 }
  51
  52 static void monst_beam_monst(int m_idx, int y, int x, int typ, int dam_hp, int monspell, bool learnable)
  53 {
  54         int flg = PROJECT_BEAM | PROJECT_KILL | PROJECT_THRU | PROJECT_MONSTER;
  55
  56         (void)project(m_idx, 0, y, x, dam_hp, typ, flg, (learnable ? monspell : -1));
  57 }
  58
  59 /*
  60  * Determine if a beam spell will hit the target.
  61  */
  62 static bool direct_beam(int y1, int x1, int y2, int x2, monster_type *m_ptr)
  63 {
  64         bool hit2 = FALSE;
  65         int i, y, x;
  66
  67         int grid_n = 0;
  68         u16b grid_g[512];
  69
  70         bool friend = is_pet(m_ptr);
  71
  72         /* Check the projection path */
  73         grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, PROJECT_THRU);
  74
  75         /* No grid is ever projectable from itself */
  76         if (!grid_n) return (FALSE);
  77
  78         for (i = 0; i < grid_n; i++)
  79         {
  80                 y = GRID_Y(grid_g[i]);
  81                 x = GRID_X(grid_g[i]);
  82
  83                 if (y == y2 && x == x2)
  84                         hit2 = TRUE;
  85                 else if (friend && cave[y][x].m_idx > 0 &&
  86                          !are_enemies(m_ptr, &m_list[cave[y][x].m_idx]))
  87                 {
  88                         /* Friends don't shoot friends */
  89                         return FALSE;
  90                 }
  91
  92                 if (friend && y == py && x == px)
  93                         return FALSE;
  94         }
  95         if (!hit2)
  96                 return FALSE;
  97         return TRUE;
  98 }
  99
 100 static bool breath_direct(int y1, int x1, int y2, int x2, int rad, bool disint_ball, bool friend)
 101 {
 102         /* Must be the same as projectable() */
 103
 104         int i, y, x;
 105
 106         int grid_n = 0;
 107         u16b grid_g[512];
 108
 109         int grids = 0;
 110         byte gx[1024], gy[1024];
 111         byte gm[32];
 112         int gm_rad = rad;
 113
 114         bool hit2 = FALSE;
 115         bool hityou = FALSE;
 116
 117         /* Check the projection path */
 118         grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, disint_ball ? PROJECT_DISI : 0);
 119         breath_shape(grid_g, grid_n, &grids, gx, gy, gm, &gm_rad, rad, y1, x1, y2, x2, disint_ball, FALSE);
 120
 121         for (i = 0; i < grids; i++)
 122         {
 123                 /* Extract the location */
 124                 y = gy[i];
 125                 x = gx[i];
 126
 127                 if (y == y2 && x == x2)
 128                         hit2 = TRUE;
 129                 if (y == py && x == px)
 130                         hityou = TRUE;
 131         }
 132         if (!hit2)
 133                 return FALSE;
 134         if (friend && hityou)
 135                 return FALSE;
 136         return TRUE;
 137 }
 138
 139 /*
 140  * Monster tries to 'cast a spell' (or breath, etc)
 141  * at another monster.
 142  *
 143  * The player is only disturbed if able to be affected by the spell.
 144  */
 145 bool monst_spell_monst(int m_idx)
 146 {
 147         int y = 0, x = 0;
 148         int i, k, t_idx;
 149         int chance, thrown_spell, count = 0;
 150         int rlev;
 151         int dam = 0;
 152         int start;
 153         int plus = 1;
 154         u32b p_mode = 0L, u_mode = 0L;
 155         int s_num_6 = (easy_band ? 2 : 6);
 156         int s_num_4 = (easy_band ? 1 : 4);
 157
 158         byte spell[96], num = 0;
 159
 160         char m_name[160];
 161         char t_name[160];
 162         char m_poss[160];
 163         char ddesc[160];
 164
 165         monster_type *m_ptr = &m_list[m_idx];
 166         monster_type *t_ptr;
 167
 168         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 169         monster_race *tr_ptr;
 170
 171         u32b f4, f5, f6;
 172
 173         bool wake_up = FALSE;
 174         bool fear = FALSE;
 175
 176         bool blind = (p_ptr->blind ? TRUE : FALSE);
 177
 178         bool see_m = m_ptr->ml;
 179         bool maneable = player_has_los_bold(m_ptr->fy, m_ptr->fx);
 180         bool learnable = (see_m && maneable && !world_monster);
 181         bool see_t;
 182         bool see_either;
 183         bool see_both;
 184         bool known;
 185
 186         bool pet = is_pet(m_ptr);
 187
 188         /* Prepare flags for summoning */
 189         if (pet) p_mode |= PM_FORCE_PET;
 190         if (!pet) u_mode |= PM_ALLOW_UNIQUE;
 191
 192         /* Cannot cast spells when confused */
 193         if (m_ptr->confused) return (FALSE);
 194
 195         /* Hack -- Extract the spell probability */
 196         chance = (r_ptr->freq_inate + r_ptr->freq_spell) / 2;
 197
 198         /* Not allowed to cast spells */
 199         if (!chance) return (FALSE);
 200
 201         if (randint0(100) >= chance) return (FALSE);
 202
 203         if (p_ptr->inside_battle)
 204         {
 205                 start = randint1(m_max-1)+m_max;
 206                 if(randint0(2)) plus = -1;
 207         }
 208         else start = m_max + 1;
 209
 210         /* Scan thru all monsters */
 211         for (i = start; ((i < start + m_max) && (i > start - m_max)); i+=plus)
 212         {
 213                 /* The monster itself isn't a target */
 214                 int dummy = (i % m_max);
 215                 if (!dummy) continue;
 216
 217                 t_idx = dummy;
 218                 t_ptr = &m_list[t_idx];
 219                 tr_ptr = &r_info[t_ptr->r_idx];
 220
 221                 /* Paranoia -- Skip dead monsters */
 222                 if (!t_ptr->r_idx) continue;
 223
 224                 if (pet)
 225                 {
 226                         if (pet_t_m_idx && (dummy != pet_t_m_idx) && !los(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx)) continue;
 227                 }
 228
 229                 /* Monster must be 'an enemy' */
 230                 if (!are_enemies(m_ptr, t_ptr)) continue;
 231
 232                 /* Extract the racial spell flags */
 233                 f4 = r_ptr->flags4;
 234                 f5 = r_ptr->flags5;
 235                 f6 = r_ptr->flags6;
 236
 237                 /* Monster must be projectable */
 238                 if (!projectable(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx))
 239                 {
 240                         bool success = FALSE;
 241                         if (m_ptr->target_y)
 242                         {
 243                                 if ((m_ptr->target_y == t_ptr->fy) && (m_ptr->target_x == t_ptr->fx))
 244                                 {
 245                                         y = m_ptr->target_y;
 246                                         x = m_ptr->target_x;
 247                                         f4 &= (RF4_INDIRECT_MASK);
 248                                         f5 &= (RF5_INDIRECT_MASK);
 249                                         f6 &= (RF6_INDIRECT_MASK);
 250                                         success = TRUE;
 251                                 }
 252                         }
 253                         if (!success) continue;
 254                 }
 255
 256                 reset_target(m_ptr);
 257
 258                 /* OK -- we've got a target */
 259                 y = t_ptr->fy;
 260                 x = t_ptr->fx;
 261
 262                 /* Extract the monster level */
 263                 rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
 264
 265                 if (pet)
 266                 {
 267                         f4 &= ~(RF4_SHRIEK);
 268                         f6 &= ~(RF6_DARKNESS | RF6_TRAPS);
 269                 }
 270
 271                 if (dun_level && (!p_ptr->inside_quest || (p_ptr->inside_quest < MIN_RANDOM_QUEST)) && (d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
 272                 {
 273                         f4 &= (RF4_NOMAGIC_MASK);
 274                         f5 &= (RF5_NOMAGIC_MASK);
 275                         f6 &= (RF6_NOMAGIC_MASK);
 276                 }
 277
 278                 if (p_ptr->inside_arena || p_ptr->inside_battle)
 279                 {
 280                         f4 &= ~(RF4_SUMMON_MASK);
 281                         f5 &= ~(RF5_SUMMON_MASK);
 282                         f6 &= ~(RF6_SUMMON_MASK);
 283                 }
 284                 if (p_ptr->inside_battle && !one_in_(3))
 285                 {
 286                         f6 &= ~(RF6_HEAL);
 287                 }
 288
 289                 if (!(p_ptr->pet_extra_flags & PF_TELEPORT) && pet)
 290                 {
 291                         f6 &= ~((RF6_BLINK | RF6_TPORT | RF6_TELE_AWAY));
 292                 }
 293
 294                 if (m_idx == p_ptr->riding)
 295                 {
 296                         f4 &= ~(RF4_RIDING_MASK);
 297                         f5 &= ~(RF5_RIDING_MASK);
 298                         f6 &= ~(RF6_RIDING_MASK);
 299                 }
 300
 301                 if (!(p_ptr->pet_extra_flags & PF_ATTACK_SPELL) && pet)
 302                 {
 303                         f4 &= ~(RF4_ATTACK_MASK);
 304                         f5 &= ~(RF5_ATTACK_MASK);
 305                         f6 &= ~(RF6_ATTACK_MASK);
 306                 }
 307
 308                 if (!(p_ptr->pet_extra_flags & PF_SUMMON_SPELL) && pet)
 309                 {
 310                         f4 &= ~(RF4_SUMMON_MASK);
 311                         f5 &= ~(RF5_SUMMON_MASK);
 312                         f6 &= ~(RF6_SUMMON_MASK);
 313                 }
 314
 315                 /* Prevent collateral damage */
 316                 if (!(p_ptr->pet_extra_flags & PF_BALL_SPELL) && pet && (m_idx != p_ptr->riding))
 317                 {
 318                         int dist = distance(py, px, y, x);
 319
 320                         /* Expected breath radius */
 321                         int rad = (r_ptr->flags2 & RF2_POWERFUL) ? 3 : 2;
 322
 323                         if (dist <= 2)
 324                         {
 325                                 f4 &= ~(RF4_BALL_MASK);
 326                                 f5 &= ~(RF5_BALL_MASK);
 327                                 f6 &= ~(RF6_BALL_MASK);
 328                         }
 329                         else if(dist <= 4)
 330                         {
 331                                 f4 &= ~(RF4_BIG_BALL_MASK);
 332                                 f5 &= ~(RF5_BIG_BALL_MASK);
 333                                 f6 &= ~(RF6_BIG_BALL_MASK);
 334                         }
 335
 336                         if (((f4 & RF4_BEAM_MASK) ||
 337                              (f5 & RF5_BEAM_MASK) ||
 338                              (f6 & RF6_BEAM_MASK)) &&
 339                             !direct_beam(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx, m_ptr))
 340                         {
 341                                 f4 &= ~(RF4_BEAM_MASK);
 342                                 f5 &= ~(RF5_BEAM_MASK);
 343                                 f6 &= ~(RF6_BEAM_MASK);
 344                         }
 345
 346                         if (((f4 & RF4_BREATH_MASK) ||
 347                           (f5 & RF5_BREATH_MASK) ||
 348                           (f6 & RF6_BREATH_MASK)) &&
 349                          !breath_direct(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx, rad, FALSE, TRUE))
 350                         {
 351                                 f4 &= ~(RF4_BREATH_MASK);
 352                                 f5 &= ~(RF5_BREATH_MASK);
 353                                 f6 &= ~(RF6_BREATH_MASK);
 354                         }
 355                         else if ((f4 & RF4_BR_DISI) &&
 356                                  !breath_direct(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx, rad, TRUE, TRUE))
 357                         {
 358                                 f4 &= ~(RF4_BR_DISI);
 359                         }
 360                 }
 361
 362                 /* Remove some spells if necessary */
 363
 364                 /* Check for a clean bolt shot */
 365                 if (((f4 & RF4_BOLT_MASK) ||
 366                      (f5 & RF5_BOLT_MASK) ||
 367                      (f6 & RF6_BOLT_MASK)) &&
 368                     !(r_ptr->flags2 & RF2_STUPID) &&
 369                     !clean_shot(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx, pet))
 370                 {
 371                         f4 &= ~(RF4_BOLT_MASK);
 372                         f5 &= ~(RF5_BOLT_MASK);
 373                         f6 &= ~(RF6_BOLT_MASK);
 374                 }
 375
 376                 /* Check for a possible summon */
 377                 if (((f4 & RF4_SUMMON_MASK) ||
 378                      (f5 & RF5_SUMMON_MASK) ||
 379                      (f6 & RF6_SUMMON_MASK)) &&
 380                     !(r_ptr->flags2 & RF2_STUPID) &&
 381                     !(summon_possible(t_ptr->fy, t_ptr->fx)))
 382                 {
 383                         /* Remove summoning spells */
 384                         f4 &= ~(RF4_SUMMON_MASK);
 385                         f5 &= ~(RF5_SUMMON_MASK);
 386                         f6 &= ~(RF6_SUMMON_MASK);
 387                 }
 388
 389                 /* Hack -- allow "desperate" spells */
 390                 if ((r_ptr->flags2 & RF2_SMART) &&
 391                         (m_ptr->hp < m_ptr->maxhp / 10) &&
 392                         (randint0(100) < 50))
 393                 {
 394                         /* Require intelligent spells */
 395                         f4 &= (RF4_INT_MASK);
 396                         f5 &= (RF5_INT_MASK);
 397                         f6 &= (RF6_INT_MASK);
 398
 399                 }
 400
 401                 /* No spells left */
 402                 if (!f4 && !f5 && !f6) return (FALSE);
 403
 404                 /* Extract the "inate" spells */
 405                 for (k = 0; k < 32; k++)
 406                 {
 407                         if (f4 & (1L << k)) spell[num++] = k + 32 * 3;
 408                 }
 409
 410                 /* Extract the "normal" spells */
 411                 for (k = 0; k < 32; k++)
 412                 {
 413                         if (f5 & (1L << k)) spell[num++] = k + 32 * 4;
 414                 }
 415
 416                 /* Extract the "bizarre" spells */
 417                 for (k = 0; k < 32; k++)
 418                 {
 419                         if (f6 & (1L << k)) spell[num++] = k + 32 * 5;
 420                 }
 421
 422                 /* No spells left */
 423                 if (!num) return (FALSE);
 424
 425                 /* Stop if player is dead or gone */
 426                 if (!p_ptr->playing || p_ptr->is_dead) return (FALSE);
 427
 428                 /* Handle "leaving" */
 429                 if (p_ptr->leaving) return (FALSE);
 430
 431                 /* Get the monster name (or "it") */
 432                 monster_desc(m_name, m_ptr, 0x00);
 433
 434                 /* Get the monster possessive ("his"/"her"/"its") */
 435                 monster_desc(m_poss, m_ptr, 0x22);
 436
 437                 /* Get the target's name (or "it") */
 438                 monster_desc(t_name, t_ptr, 0x00);
 439
 440                 /* Hack -- Get the "died from" name */
 441                 monster_desc(ddesc, m_ptr, 0x88);
 442
 443                 /* Choose a spell to cast */
 444                 thrown_spell = spell[randint0(num)];
 445
 446                 see_t = t_ptr->ml;
 447                 see_either = (see_m || see_t);
 448                 see_both = (see_m && see_t);
 449
 450                 /* Can the player be aware of this attack? */
 451                 known = (m_ptr->cdis <= MAX_SIGHT) || (t_ptr->cdis <= MAX_SIGHT);
 452
 453                 if (p_ptr->riding && (m_idx == p_ptr->riding)) disturb(1, 0);
 454
 455                 /* Check for spell failure (inate attacks never fail) */
 456                 if ((thrown_spell >= 128) && m_ptr->stunned && one_in_(2))
 457                 {
 458                         disturb(1, 0);
 459                         /* Message */
 460                         if (thrown_spell != (160+7)) /* Not RF6_SPECIAL */
 461                         {
 462 #ifdef JP
 463 msg_format("%^s¤Ï¼öÊ¸¤ò¾§¤¨¤è¤¦¤È¤·¤¿¤¬¼ºÇÔ¤·¤¿¡£", m_name);
 464 #else
 465                                 msg_format("%^s tries to cast a spell, but fails.", m_name);
 466 #endif
 467                         }
 468
 469                         return (TRUE);
 470                 }
 471
 472                 switch (thrown_spell)
 473                 {
 474                         /* RF4_SHRIEK */
 475                         case 96+0:
 476                         {
 477                                 if (known)
 478                                 {
 479                                         if (see_m)
 480                                         {
 481 #ifdef JP
 482 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¶«¤ó¤À¡£", m_name, t_name);
 483 #else
 484                                                 msg_format("%^s shrieks at %s.", m_name, t_name);
 485 #endif
 486
 487                                         }
 488                                         else
 489                                         {
 490                                                 mon_fight = TRUE;
 491                                         }
 492                                 }
 493
 494                                 wake_up = TRUE;
 495
 496                                 break;
 497                         }
 498
 499                         /* RF4_XXX1 */
 500                         case 96+1:
 501                         {
 502                                 /* XXX XXX XXX */
 503                                 return FALSE;
 504                         }
 505
 506                         /* RF4_DISPEL */
 507                         case 96+2:
 508                         {
 509                                 return FALSE;
 510                         }
 511
 512                         /* RF4_XXX4X4 */
 513                         case 96+3:
 514                         {
 515                                 if (known)
 516                                 {
 517                                         if (see_either)
 518                                         {
 519                                                 disturb(1, 0);
 520
 521                                                 if (blind)
 522                                                 {
 523 #ifdef JP
 524 msg_format("%^s¤¬²¿¤«¤ò¼Í¤Ã¤¿¡£", m_name);
 525 #else
 526                                                         msg_format("%^s shoots something.", m_name);
 527 #endif
 528
 529                                                 }
 530                                                 else
 531                                                 {
 532 #ifdef JP
 533 msg_format("%^s¤¬%s¤Ë¥í¥±¥Ã¥È¤òÈ¯¼Í¤·¤¿¡£", m_name, t_name);
 534 #else
 535                                                         msg_format("%^s fires a rocket at %s.", m_name, t_name);
 536 #endif
 537
 538                                                 }
 539                                         }
 540                                         else
 541                                         {
 542                                                 mon_fight = TRUE;
 543                                         }
 544                                 }
 545
 546                                 dam = ((m_ptr->hp / 4) > 800 ? 800 : (m_ptr->hp / 4));
 547                                 monst_breath_monst(m_idx, y, x, GF_ROCKET,
 548                                         dam, 2, FALSE, MS_ROCKET, learnable);
 549
 550                                 break;
 551                         }
 552
 553                         /* RF4_SHOOT */
 554                         case 96+4:
 555                         {
 556                                 if (known)
 557                                 {
 558                                         if (see_either)
 559                                         {
 560                                                 if (blind)
 561                                                 {
 562 #ifdef JP
 563 msg_format("%^s¤¬´ñÌ¯¤Ê²»¤òÈ¯¤·¤¿¡£", m_name);
 564 #else
 565                                                         msg_format("%^s makes a strange noise.", m_name);
 566 #endif
 567
 568                                                 }
 569                                                 else
 570                                                 {
 571 #ifdef JP
 572 msg_format("%^s¤¬%s¤ËÌð¤òÊü¤Ã¤¿¡£", m_name, t_name);
 573 #else
 574                                                         msg_format("%^s fires an arrow at %s.", m_name, t_name);
 575 #endif
 576
 577                                                 }
 578                                         }
 579                                         else
 580                                         {
 581                                                 mon_fight = TRUE;
 582                                         }
 583
 584                                         sound(SOUND_SHOOT);
 585                                 }
 586
 587                                 dam = damroll(r_ptr->blow[0].d_dice, r_ptr->blow[0].d_side);
 588                                 monst_bolt_monst(m_idx, y, x, GF_ARROW, dam, MS_SHOOT, learnable);
 589
 590                                 break;
 591                         }
 592
 593                         /* RF4_XXX2 */
 594                         case 96+5:
 595                         {
 596                                 /* XXX XXX XXX */
 597                                 return FALSE;
 598                         }
 599
 600                         /* RF4_XXX3 */
 601                         case 96+6:
 602                         {
 603                                 /* XXX XXX XXX */
 604                                 return FALSE;
 605                         }
 606
 607                         /* RF4_XXX4 */
 608                         case 96+7:
 609                         {
 610                                 /* XXX XXX XXX */
 611                                 return FALSE;
 612                         }
 613
 614                         /* RF4_BR_ACID */
 615                         case 96+8:
 616                         {
 617                                 if (known)
 618                                 {
 619                                         if (see_either)
 620                                         {
 621                                                 disturb(1, 0);
 622
 623                                                 if (blind)
 624                                                 {
 625 #ifdef JP
 626 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 627 #else
 628                                                         msg_format("%^s breathes.", m_name);
 629 #endif
 630
 631                                                 }
 632                                                 else
 633                                                 {
 634 #ifdef JP
 635 msg_format("%^s¤¬%s¤Ë»À¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 636 #else
 637                                                         msg_format("%^s breathes acid at %s.", m_name, t_name);
 638 #endif
 639
 640                                                 }
 641                                         }
 642                                         else
 643                                         {
 644                                                 mon_fight = TRUE;
 645                                         }
 646
 647                                         sound(SOUND_BREATH);
 648                                 }
 649
 650                                 dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
 651                                 monst_breath_monst(m_idx, y, x, GF_ACID,
 652                                         dam,0, TRUE, MS_BR_ACID, learnable);
 653
 654                                 break;
 655                         }
 656
 657                         /* RF4_BR_ELEC */
 658                         case 96+9:
 659                         {
 660                                 if (known)
 661                                 {
 662                                         if (see_either)
 663                                         {
 664                                                 disturb(1, 0);
 665
 666                                                 if (blind)
 667                                                 {
 668 #ifdef JP
 669 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 670 #else
 671                                                         msg_format("%^s breathes.", m_name);
 672 #endif
 673
 674                                                 }
 675                                                 else
 676                                                 {
 677 #ifdef JP
 678 msg_format("%^s¤¬%s¤Ë°ðºÊ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 679 #else
 680                                                         msg_format("%^s breathes lightning at %s.", m_name, t_name);
 681 #endif
 682
 683                                                 }
 684                                         }
 685                                         else
 686                                         {
 687                                                 mon_fight = TRUE;
 688                                         }
 689
 690                                         sound(SOUND_BREATH);
 691                                 }
 692
 693                                 dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
 694                                 monst_breath_monst(m_idx, y, x, GF_ELEC,
 695                                         dam,0, TRUE, MS_BR_ELEC, learnable);
 696
 697                                 break;
 698                         }
 699
 700                         /* RF4_BR_FIRE */
 701                         case 96+10:
 702                         {
 703                                 if (known)
 704                                 {
 705                                         if (see_either)
 706                                         {
 707                                                 disturb(1, 0);
 708
 709                                                 if (blind)
 710                                                 {
 711 #ifdef JP
 712 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 713 #else
 714                                                         msg_format("%^s breathes.", m_name);
 715 #endif
 716
 717                                                 }
 718                                                 else
 719                                                 {
 720 #ifdef JP
 721 msg_format("%^s¤¬%s¤Ë²Ð±ê¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 722 #else
 723                                                         msg_format("%^s breathes fire at %s.", m_name, t_name);
 724 #endif
 725
 726                                                 }
 727                                         }
 728                                         else
 729                                         {
 730                                                 mon_fight = TRUE;
 731                                         }
 732
 733                                         sound(SOUND_BREATH);
 734                                 }
 735
 736                                 dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
 737                                 monst_breath_monst(m_idx, y, x, GF_FIRE,
 738                                         dam,0, TRUE, MS_BR_FIRE, learnable);
 739
 740                                 break;
 741                         }
 742
 743                         /* RF4_BR_COLD */
 744                         case 96+11:
 745                         {
 746                                 if (known)
 747                                 {
 748                                         if (see_either)
 749                                         {
 750                                                 disturb(1, 0);
 751
 752                                                 if (blind)
 753                                                 {
 754 #ifdef JP
 755 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 756 #else
 757                                                         msg_format("%^s breathes.", m_name);
 758 #endif
 759
 760                                                 }
 761                                                 else
 762                                                 {
 763 #ifdef JP
 764 msg_format("%^s¤¬%s¤ËÎäµ¤¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 765 #else
 766                                                         msg_format("%^s breathes frost at %s.", m_name, t_name);
 767 #endif
 768
 769                                                 }
 770                                         }
 771                                         else
 772                                         {
 773                                                 mon_fight = TRUE;
 774                                         }
 775
 776                                         sound(SOUND_BREATH);
 777                                 }
 778
 779                                 dam = ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3));
 780                                 monst_breath_monst(m_idx, y, x, GF_COLD,
 781                                         dam,0, TRUE, MS_BR_COLD, learnable);
 782                                 break;
 783                         }
 784
 785                         /* RF4_BR_POIS */
 786                         case 96+12:
 787                         {
 788                                 if (known)
 789                                 {
 790                                         if (see_either)
 791                                         {
 792                                                 disturb(1, 0);
 793
 794                                                 if (blind)
 795                                                 {
 796 #ifdef JP
 797 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 798 #else
 799                                                         msg_format("%^s breathes.", m_name);
 800 #endif
 801
 802                                                 }
 803                                                 else
 804                                                 {
 805 #ifdef JP
 806 msg_format("%^s¤¬%s¤Ë¥¬¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 807 #else
 808                                                         msg_format("%^s breathes gas at %s.", m_name, t_name);
 809 #endif
 810
 811                                                 }
 812                                         }
 813                                         else
 814                                         {
 815                                                 mon_fight = TRUE;
 816                                         }
 817
 818                                         sound(SOUND_BREATH);
 819                                 }
 820
 821                                 dam = ((m_ptr->hp / 3) > 800 ? 800 : (m_ptr->hp / 3));
 822                                 monst_breath_monst(m_idx, y, x, GF_POIS,
 823                                         dam,0, TRUE, MS_BR_POIS, learnable);
 824
 825                                 break;
 826                         }
 827
 828                         /* RF4_BR_NETH */
 829                         case 96+13:
 830                         {
 831                                 if (known)
 832                                 {
 833                                         if (see_either)
 834                                         {
 835                                                 disturb(1, 0);
 836
 837                                                 if (blind)
 838                                                 {
 839 #ifdef JP
 840 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 841 #else
 842                                                         msg_format("%^s breathes.", m_name);
 843 #endif
 844
 845                                                 }
 846                                                 else
 847                                                 {
 848 #ifdef JP
 849 msg_format("%^s¤¬%s¤ËÃÏ¹ö¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 850 #else
 851                                                         msg_format("%^s breathes nether at %s.", m_name, t_name);
 852 #endif
 853
 854                                                 }
 855                                         }
 856                                         else
 857                                         {
 858                                                 mon_fight = TRUE;
 859                                         }
 860
 861                                         sound(SOUND_BREATH);
 862                                 }
 863
 864                                 dam = ((m_ptr->hp / 6) > 550 ? 550 : (m_ptr->hp / 6));
 865                                 monst_breath_monst(m_idx, y, x, GF_NETHER,
 866                                         dam,0, TRUE, MS_BR_NETHER, learnable);
 867
 868                                 break;
 869                         }
 870
 871                         /* RF4_BR_LITE */
 872                         case 96+14:
 873                         {
 874                                 if (known)
 875                                 {
 876                                         if (see_either)
 877                                         {
 878                                                 disturb(1, 0);
 879
 880                                                 if (blind)
 881                                                 {
 882 #ifdef JP
 883 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 884 #else
 885                                                         msg_format("%^s breathes.", m_name);
 886 #endif
 887
 888                                                 }
 889                                                 else
 890                                                 {
 891 #ifdef JP
 892 msg_format("%^s¤¬%s¤ËÁ®¸÷¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 893 #else
 894                                                         msg_format("%^s breathes light at %s.", m_name, t_name);
 895 #endif
 896
 897                                                 }
 898                                         }
 899                                         else
 900                                         {
 901                                                 mon_fight = TRUE;
 902                                         }
 903
 904                                         sound(SOUND_BREATH);
 905                                 }
 906
 907                                 dam = ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6));
 908                                 monst_breath_monst(m_idx, y, x, GF_LITE,
 909                                         dam,0, TRUE, MS_BR_LITE, learnable);
 910
 911                                 break;
 912                         }
 913
 914                         /* RF4_BR_DARK */
 915                         case 96+15:
 916                         {
 917                                 if (known)
 918                                 {
 919                                         if (see_either)
 920                                         {
 921                                                 disturb(1, 0);
 922
 923                                                 if (blind)
 924                                                 {
 925 #ifdef JP
 926 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 927 #else
 928                                                         msg_format("%^s breathes.", m_name);
 929 #endif
 930
 931                                                 }
 932                                                 else
 933                                                 {
 934 #ifdef JP
 935 msg_format("%^s¤¬%s¤Ë°Å¹õ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 936 #else
 937                                                         msg_format("%^s breathes darkness at %s.", m_name, t_name);
 938 #endif
 939
 940                                                 }
 941                                         }
 942                                         else
 943                                         {
 944                                                 mon_fight = TRUE;
 945                                         }
 946
 947                                         sound(SOUND_BREATH);
 948                                 }
 949
 950                                 dam = ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6));
 951                                 monst_breath_monst(m_idx, y, x, GF_DARK,
 952                                         dam,0, TRUE, MS_BR_DARK, learnable);
 953
 954                                 break;
 955                         }
 956
 957                         /* RF4_BR_CONF */
 958                         case 96+16:
 959                         {
 960                                 if (known)
 961                                 {
 962                                         if (see_either)
 963                                         {
 964                                                 disturb(1, 0);
 965
 966                                                 if (blind)
 967                                                 {
 968 #ifdef JP
 969 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
 970 #else
 971                                                         msg_format("%^s breathes.", m_name);
 972 #endif
 973
 974                                                 }
 975                                                 else
 976                                                 {
 977 #ifdef JP
 978 msg_format("%^s¤¬%s¤Ëº®Íð¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
 979 #else
 980                                                         msg_format("%^s breathes confusion at %s.", m_name, t_name);
 981 #endif
 982
 983                                                 }
 984                                         }
 985                                         else
 986                                         {
 987                                                 mon_fight = TRUE;
 988                                         }
 989
 990                                         sound(SOUND_BREATH);
 991                                 }
 992
 993                                 dam = ((m_ptr->hp / 6) > 450 ? 450 : (m_ptr->hp / 6));
 994                                 monst_breath_monst(m_idx, y, x, GF_CONFUSION,
 995                                         dam,0, TRUE, MS_BR_CONF, learnable);
 996
 997                                 break;
 998                         }
 999
1000                         /* RF4_BR_SOUN */
1001                         case 96+17:
1002                         {
1003                                 if (known)
1004                                 {
1005                                         if (see_either)
1006                                         {
1007                                                 disturb(1, 0);
1008
1009                                                 if (m_ptr->r_idx == MON_JAIAN)
1010 #ifdef JP
1011                                                         msg_format("¡Ö¥Ü¥©¥¨¡Á¡Á¡Á¡Á¡Á¡Á¡×");
1012 #else
1013                                                         msg_format("'Booooeeeeee'");
1014 #endif
1015                                                 else if (blind)
1016                                                 {
1017 #ifdef JP
1018 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1019 #else
1020                                                         msg_format("%^s breathes.", m_name);
1021 #endif
1022
1023                                                 }
1024                                                 else
1025                                                 {
1026 #ifdef JP
1027 msg_format("%^s¤¬%s¤Ë¹ì²»¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1028 #else
1029                                                         msg_format("%^s breathes sound at %s.", m_name, t_name);
1030 #endif
1031
1032                                                 }
1033                                         }
1034                                         else
1035                                         {
1036                                                 mon_fight = TRUE;
1037                                         }
1038
1039                                         sound(SOUND_BREATH);
1040                                 }
1041
1042                                 dam = ((m_ptr->hp / 6) > 450 ? 450 : (m_ptr->hp / 6));
1043                                 monst_breath_monst(m_idx, y, x, GF_SOUND,
1044                                         dam,0, TRUE, MS_BR_SOUND, learnable);
1045
1046                                 break;
1047                         }
1048
1049                         /* RF4_BR_CHAO */
1050                         case 96+18:
1051                         {
1052                                 if (known)
1053                                 {
1054                                         if (see_either)
1055                                         {
1056                                                 disturb(1, 0);
1057
1058                                                 if (blind)
1059                                                 {
1060 #ifdef JP
1061 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1062 #else
1063                                                         msg_format("%^s breathes.", m_name);
1064 #endif
1065
1066                                                 }
1067                                                 else
1068                                                 {
1069 #ifdef JP
1070 msg_format("%^s¤¬%s¤Ë¥«¥ª¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1071 #else
1072                                                         msg_format("%^s breathes chaos at %s.", m_name, t_name);
1073 #endif
1074
1075                                                 }
1076                                         }
1077                                         else
1078                                         {
1079                                                 mon_fight = TRUE;
1080                                         }
1081
1082                                         sound(SOUND_BREATH);
1083                                 }
1084
1085                                 dam = ((m_ptr->hp / 6) > 600 ? 600 : (m_ptr->hp / 6));
1086                                 monst_breath_monst(m_idx, y, x, GF_CHAOS,
1087                                         dam,0, TRUE, MS_BR_CHAOS, learnable);
1088
1089                                 break;
1090                         }
1091
1092                         /* RF4_BR_DISE */
1093                         case 96+19:
1094                         {
1095                                 if (known)
1096                                 {
1097                                         if (see_either)
1098                                         {
1099                                                 disturb(1, 0);
1100
1101                                                 if (blind)
1102                                                 {
1103 #ifdef JP
1104 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1105 #else
1106                                                         msg_format("%^s breathes.", m_name);
1107 #endif
1108
1109                                                 }
1110                                                 else
1111                                                 {
1112 #ifdef JP
1113 msg_format("%^s¤¬%s¤ËÎô²½¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1114 #else
1115                                                         msg_format("%^s breathes disenchantment at %s.", m_name, t_name);
1116 #endif
1117
1118                                                 }
1119                                         }
1120                                         else
1121                                         {
1122                                                 mon_fight = TRUE;
1123                                         }
1124
1125                                         sound(SOUND_BREATH);
1126                                 }
1127
1128                                 dam = ((m_ptr->hp / 6) > 500 ? 500 : (m_ptr->hp / 6));
1129                                 monst_breath_monst(m_idx, y, x, GF_DISENCHANT,
1130                                         dam,0, TRUE, MS_BR_DISEN, learnable);
1131
1132                                 break;
1133                         }
1134
1135                         /* RF4_BR_NEXU */
1136                         case 96+20:
1137                         {
1138                                 if (known)
1139                                 {
1140                                         if (see_either)
1141                                         {
1142                                                 disturb(1, 0);
1143
1144                                                 if (blind)
1145                                                 {
1146 #ifdef JP
1147 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1148 #else
1149                                                         msg_format("%^s breathes.", m_name);
1150 #endif
1151
1152                                                 }
1153                                                 else
1154                                                 {
1155 #ifdef JP
1156 msg_format("%^s¤¬%s¤Ë°ø²Ìº®Íð¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1157 #else
1158                                                         msg_format("%^s breathes nexus at %s.", m_name, t_name);
1159 #endif
1160
1161                                                 }
1162                                         }
1163                                         else
1164                                         {
1165                                                 mon_fight = TRUE;
1166                                         }
1167
1168                                         sound(SOUND_BREATH);
1169                                 }
1170
1171                                 dam = ((m_ptr->hp / 3) > 250 ? 250 : (m_ptr->hp / 3));
1172                                 monst_breath_monst(m_idx, y, x, GF_NEXUS,
1173                                         dam,0, TRUE, MS_BR_NEXUS, learnable);
1174
1175                                 break;
1176                         }
1177
1178                         /* RF4_BR_TIME */
1179                         case 96+21:
1180                         {
1181                                 if (known)
1182                                 {
1183                                         if (see_either)
1184                                         {
1185                                                 disturb(1, 0);
1186
1187                                                 if (blind)
1188                                                 {
1189 #ifdef JP
1190 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1191 #else
1192                                                         msg_format("%^s breathes.", m_name);
1193 #endif
1194
1195                                                 }
1196                                                 else
1197                                                 {
1198 #ifdef JP
1199 msg_format("%^s¤¬%s¤Ë»þ´ÖµÕÅ¾¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1200 #else
1201                                                         msg_format("%^s breathes time at %s.", m_name, t_name);
1202 #endif
1203
1204                                                 }
1205                                         }
1206                                         else
1207                                         {
1208                                                 mon_fight = TRUE;
1209                                         }
1210
1211                                         sound(SOUND_BREATH);
1212                                 }
1213
1214                                 dam = ((m_ptr->hp / 3) > 150 ? 150 : (m_ptr->hp / 3));
1215                                 monst_breath_monst(m_idx, y, x, GF_TIME,
1216                                         dam,0, TRUE, MS_BR_TIME, learnable);
1217
1218                                 break;
1219                         }
1220
1221                         /* RF4_BR_INER */
1222                         case 96+22:
1223                         {
1224                                 if (known)
1225                                 {
1226                                         if (see_either)
1227                                         {
1228                                                 disturb(1, 0);
1229
1230                                                 if (blind)
1231                                                 {
1232 #ifdef JP
1233 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1234 #else
1235                                                         msg_format("%^s breathes.", m_name);
1236 #endif
1237
1238                                                 }
1239                                                 else
1240                                                 {
1241 #ifdef JP
1242 msg_format("%^s¤¬%s¤ËÃÙÆß¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1243 #else
1244                                                         msg_format("%^s breathes inertia at %s.", m_name, t_name);
1245 #endif
1246
1247                                                 }
1248                                         }
1249                                         else
1250                                         {
1251                                                 mon_fight = TRUE;
1252                                         }
1253
1254                                         sound(SOUND_BREATH);
1255                                 }
1256
1257                                 dam = ((m_ptr->hp / 6) > 200 ? 200 : (m_ptr->hp / 6));
1258                                 monst_breath_monst(m_idx, y, x, GF_INERTIA,
1259                                         dam,0, TRUE, MS_BR_INERTIA, learnable);
1260
1261                                 break;
1262                         }
1263
1264                         /* RF4_BR_GRAV */
1265                         case 96+23:
1266                         {
1267                                 if (known)
1268                                 {
1269                                         if (see_either)
1270                                         {
1271                                                 disturb(1, 0);
1272
1273                                                 if (blind)
1274                                                 {
1275 #ifdef JP
1276 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1277 #else
1278                                                         msg_format("%^s breathes.", m_name);
1279 #endif
1280
1281                                                 }
1282                                                 else
1283                                                 {
1284 #ifdef JP
1285 msg_format("%^s¤¬%s¤Ë½ÅÎÏ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1286 #else
1287                                                         msg_format("%^s breathes gravity at %s.", m_name, t_name);
1288 #endif
1289
1290                                                 }
1291                                         }
1292                                         else
1293                                         {
1294                                                 mon_fight = TRUE;
1295                                         }
1296
1297                                         sound(SOUND_BREATH);
1298                                 }
1299
1300                                 dam = ((m_ptr->hp / 3) > 200 ? 200 : (m_ptr->hp / 3));
1301                                 monst_breath_monst(m_idx, y, x, GF_GRAVITY,
1302                                         dam,0, TRUE, MS_BR_GRAVITY, learnable);
1303
1304                                 break;
1305                         }
1306
1307                         /* RF4_BR_SHAR */
1308                         case 96+24:
1309                         {
1310                                 if (known)
1311                                 {
1312                                         if (see_either)
1313                                         {
1314                                                 disturb(1, 0);
1315
1316                                                 if (m_ptr->r_idx == MON_BOTEI)
1317 #ifdef JP
1318                                                         msg_format("¡Ö¥ÜÄë¥Ó¥ë¥«¥Ã¥¿¡¼¡ª¡ª¡ª¡×");
1319 #else
1320                                                         msg_format("'Boty-Build cutter!!!'");
1321 #endif
1322                                                 else if (blind)
1323                                                 {
1324 #ifdef JP
1325 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1326 #else
1327                                                         msg_format("%^s breathes.", m_name);
1328 #endif
1329
1330                                                 }
1331                                                 else
1332                                                 {
1333 #ifdef JP
1334 msg_format("%^s¤¬%s¤ËÇËÊÒ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1335 #else
1336                                                         msg_format("%^s breathes shards at %s.", m_name, t_name);
1337 #endif
1338
1339                                                 }
1340                                         }
1341                                         else
1342                                         {
1343                                                 mon_fight = TRUE;
1344                                         }
1345
1346                                         sound(SOUND_BREATH);
1347                                 }
1348
1349                                 dam = ((m_ptr->hp / 6) > 500 ? 500 : (m_ptr->hp / 6));
1350                                 monst_breath_monst(m_idx, y, x, GF_SHARDS,
1351                                         dam,0, TRUE, MS_BR_SHARDS, learnable);
1352
1353                                 break;
1354                         }
1355
1356                         /* RF4_BR_PLAS */
1357                         case 96+25:
1358                         {
1359                                 if (known)
1360                                 {
1361                                         if (see_either)
1362                                         {
1363                                                 disturb(1, 0);
1364
1365                                                 if (blind)
1366                                                 {
1367 #ifdef JP
1368 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1369 #else
1370                                                         msg_format("%^s breathes.", m_name);
1371 #endif
1372
1373                                                 }
1374                                                 else
1375                                                 {
1376 #ifdef JP
1377 msg_format("%^s¤¬%s¤Ë¥×¥é¥º¥Þ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1378 #else
1379                                                         msg_format("%^s breathes plasma at %s.", m_name, t_name);
1380 #endif
1381
1382                                                 }
1383                                         }
1384                                         else
1385                                         {
1386                                                 mon_fight = TRUE;
1387                                         }
1388
1389                                         sound(SOUND_BREATH);
1390                                 }
1391
1392                                 dam = ((m_ptr->hp / 6) > 150 ? 150 : (m_ptr->hp / 6));
1393                                 monst_breath_monst(m_idx, y, x, GF_PLASMA,
1394                                         dam,0, TRUE, MS_BR_PLASMA, learnable);
1395
1396                                 break;
1397                         }
1398
1399                         /* RF4_BR_WALL */
1400                         case 96+26:
1401                         {
1402                                 if (known)
1403                                 {
1404                                         if (see_either)
1405                                         {
1406                                                 disturb(1, 0);
1407
1408                                                 if (blind)
1409                                                 {
1410 #ifdef JP
1411 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1412 #else
1413                                                         msg_format("%^s breathes.", m_name);
1414 #endif
1415
1416                                                 }
1417                                                 else
1418                                                 {
1419 #ifdef JP
1420 msg_format("%^s¤¬%s¤Ë¥Õ¥©¡¼¥¹¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1421 #else
1422                                                         msg_format("%^s breathes force at %s.", m_name, t_name);
1423 #endif
1424
1425                                                 }
1426                                         }
1427                                         else
1428                                         {
1429                                                 mon_fight = TRUE;
1430                                         }
1431
1432                                         sound(SOUND_BREATH);
1433                                 }
1434
1435                                 dam = ((m_ptr->hp / 6) > 200 ? 200 : (m_ptr->hp / 6));
1436                                 monst_breath_monst(m_idx, y, x, GF_FORCE,
1437                                         dam,0, TRUE, MS_BR_FORCE, learnable);
1438                                 break;
1439                         }
1440
1441                         /* RF4_BR_MANA */
1442                         case 96+27:
1443                         {
1444                                 if (known)
1445                                 {
1446                                         if (see_either)
1447                                         {
1448                                                 disturb(1, 0);
1449
1450                                                 if (blind)
1451                                                 {
1452 #ifdef JP
1453 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1454 #else
1455                                                         msg_format("%^s breathes.", m_name);
1456 #endif
1457
1458                                                 }
1459                                                 else
1460                                                 {
1461 #ifdef JP
1462 msg_format("%^s¤¬%s¤ËËâÎÏ¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1463 #else
1464                                                         msg_format("%^s breathes mana at %s.", m_name, t_name);
1465 #endif
1466
1467                                                 }
1468                                         }
1469                                         else
1470                                         {
1471                                                 mon_fight = TRUE;
1472                                         }
1473
1474                                         sound(SOUND_BREATH);
1475                                 }
1476
1477                                 dam = ((m_ptr->hp / 3) > 250 ? 250 : (m_ptr->hp / 3));
1478                                 monst_breath_monst(m_idx, y, x, GF_MANA,
1479                                         dam,0, TRUE, MS_BR_MANA, learnable);
1480
1481                                 break;
1482                         }
1483
1484                         /* RF4_BA_NUKE */
1485                         case 96+28:
1486                         {
1487                                 if (known)
1488                                 {
1489                                         if (see_either)
1490                                         {
1491                                                 disturb(1, 0);
1492
1493                                                 if (blind)
1494                                                 {
1495 #ifdef JP
1496 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1497 #else
1498                                                         msg_format("%^s mumbles.", m_name);
1499 #endif
1500
1501                                                 }
1502                                                 else
1503                                                 {
1504 #ifdef JP
1505 msg_format("%^s¤¬%s¤ËÊü¼ÍÇ½µå¤òÊü¤Ã¤¿¡£", m_name, t_name);
1506 #else
1507                                                         msg_format("%^s casts a ball of radiation at %s.", m_name, t_name);
1508 #endif
1509
1510                                                 }
1511                                         }
1512                                         else
1513                                         {
1514                                                 mon_fight = TRUE;
1515                                         }
1516                                 }
1517
1518                                 dam = (rlev + damroll(10, 6));
1519                                 monst_breath_monst(m_idx, y, x, GF_NUKE,
1520                                         dam, 2, FALSE, MS_BALL_NUKE, learnable);
1521
1522                                 break;
1523                         }
1524
1525                         /* RF4_RF4_BR_NUKE */
1526                         case 96+29:
1527                         {
1528                                 if (known)
1529                                 {
1530                                         if (see_either)
1531                                         {
1532                                                 disturb(1, 0);
1533
1534                                                 if (blind)
1535                                                 {
1536 #ifdef JP
1537 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1538 #else
1539                                                         msg_format("%^s breathes.", m_name);
1540 #endif
1541
1542                                                 }
1543                                                 else
1544                                                 {
1545 #ifdef JP
1546 msg_format("%^s¤¬%s¤ËÊü¼ÍÀÇÑ´þÊª¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1547 #else
1548                                                         msg_format("%^s breathes toxic waste at %s.", m_name, t_name);
1549 #endif
1550
1551                                                 }
1552                                         }
1553                                         else
1554                                         {
1555                                                 mon_fight = TRUE;
1556                                         }
1557
1558                                         sound(SOUND_BREATH);
1559                                 }
1560
1561                                 dam = ((m_ptr->hp / 3) > 800 ? 800 : (m_ptr->hp / 3));
1562                                 monst_breath_monst(m_idx, y, x, GF_NUKE,
1563                                         dam,0, TRUE, MS_BR_NUKE, learnable);
1564                                 break;
1565                         }
1566
1567                         /* RF4_BA_CHAO */
1568                         case 96+30:
1569                         {
1570                                 if (known)
1571                                 {
1572                                         if (see_either)
1573                                         {
1574                                                 disturb(1, 0);
1575
1576                                                 if (blind)
1577                                                 {
1578 #ifdef JP
1579 msg_format("%^s¤¬¶²¤í¤·¤²¤Ë¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1580 #else
1581                                                         msg_format("%^s mumbles frighteningly.", m_name);
1582 #endif
1583
1584                                                 }
1585                                                 else
1586                                                 {
1587 #ifdef JP
1588 msg_format("%^s¤¬%s¤Ë½ã¥í¥°¥ë¥¹¤òÊü¤Ã¤¿¡£", m_name, t_name);
1589 #else
1590                                                         msg_format("%^s invokes raw Logrus upon %s.", m_name, t_name);
1591 #endif
1592
1593                                                 }
1594                                         }
1595                                         else
1596                                         {
1597                                                 mon_fight = TRUE;
1598                                         }
1599                                 }
1600
1601                                 dam = (rlev * 2) + damroll(10, 10);
1602                                 monst_breath_monst(m_idx, y, x, GF_CHAOS,
1603                                         dam, 4, FALSE, MS_BALL_CHAOS, learnable);
1604
1605                                 break;
1606                         }
1607
1608                         /* RF4_BR_DISI */
1609                         case 96+31:
1610                         {
1611                                 if (known)
1612                                 {
1613                                         if (see_either)
1614                                         {
1615                                                 disturb(1, 0);
1616
1617                                                 if (blind)
1618                                                 {
1619 #ifdef JP
1620 msg_format("%^s¤¬²¿¤«¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name);
1621 #else
1622                                                         msg_format("%^s breathes.", m_name);
1623 #endif
1624
1625                                                 }
1626                                                 else
1627                                                 {
1628 #ifdef JP
1629 msg_format("%^s¤¬%s¤ËÊ¬²ò¤Î¥Ö¥ì¥¹¤òÅÇ¤¤¤¿¡£", m_name, t_name);
1630 #else
1631                                                         msg_format("%^s breathes disintegration at %s.", m_name, t_name);
1632 #endif
1633
1634                                                 }
1635                                         }
1636                                         else
1637                                         {
1638                                                 mon_fight = TRUE;
1639                                         }
1640
1641                                         sound(SOUND_BREATH);
1642                                 }
1643
1644                                 dam = ((m_ptr->hp / 6) > 150 ? 150 : (m_ptr->hp / 6));
1645                                 monst_breath_monst(m_idx, y, x, GF_DISINTEGRATE,
1646                                         dam,0, TRUE, MS_BR_DISI, learnable);
1647                                 break;
1648                         }
1649
1650                         /* RF5_BA_ACID */
1651                         case 128+0:
1652                         {
1653                                 if (known)
1654                                 {
1655                                         if (see_either)
1656                                         {
1657                                                 disturb(1, 0);
1658
1659                                                 if (blind)
1660                                                 {
1661 #ifdef JP
1662 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1663 #else
1664                                                         msg_format("%^s mumbles.", m_name);
1665 #endif
1666
1667                                                 }
1668                                                 else
1669                                                 {
1670 #ifdef JP
1671 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¢¥·¥Ã¥É¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
1672 #else
1673                                                         msg_format("%^s casts an acid ball at %s.", m_name, t_name);
1674 #endif
1675
1676                                                 }
1677                                         }
1678                                         else
1679                                         {
1680                                                 mon_fight = TRUE;
1681                                         }
1682                                 }
1683
1684                                 dam = (randint1(rlev * 3) + 15) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
1685                                 monst_breath_monst(m_idx, y, x, GF_ACID, dam, 2, FALSE, MS_BALL_ACID, learnable);
1686
1687                                 break;
1688                         }
1689
1690                         /* RF5_BA_ELEC */
1691                         case 128+1:
1692                         {
1693                                 if (known)
1694                                 {
1695                                         if (see_either)
1696                                         {
1697                                                 disturb(1, 0);
1698
1699                                                 if (blind)
1700                                                 {
1701 #ifdef JP
1702 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1703 #else
1704                                                         msg_format("%^s mumbles.", m_name);
1705 #endif
1706
1707                                                 }
1708                                                 else
1709                                                 {
1710 #ifdef JP
1711 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥µ¥ó¥À¡¼¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
1712 #else
1713                                                         msg_format("%^s casts a lightning ball at %s.", m_name, t_name);
1714 #endif
1715
1716                                                 }
1717                                         }
1718                                         else
1719                                         {
1720                                                 mon_fight = TRUE;
1721                                         }
1722                                 }
1723
1724                                 dam = (randint1(rlev * 3 / 2) + 8) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
1725                                 monst_breath_monst(m_idx, y, x, GF_ELEC, dam, 2, FALSE, MS_BALL_ELEC, learnable);
1726
1727                                 break;
1728                         }
1729
1730                         /* RF5_BA_FIRE */
1731                         case 128+2:
1732                         {
1733                                 if (known)
1734                                 {
1735                                         if (see_either)
1736                                         {
1737                                                 disturb(1, 0);
1738
1739                                                 if (m_ptr->r_idx == MON_ROLENTO)
1740                                                 {
1741 #ifdef JP
1742 if (blind)
1743         msg_format("%^s¤¬²¿¤«¤òÅê¤²¤¿¡£", m_name);
1744 else
1745         msg_format("%^s¤¬%^s¤Ë¸þ¤«¤Ã¤Æ¼êÜØÃÆ¤òÅê¤²¤¿¡£", m_name, t_name);
1746 #else
1747 if (blind)
1748         msg_format("%^s throws something.", m_name);
1749 else
1750         msg_format("%^s throws a hand grenade.", m_name);
1751 #endif
1752                                                 }
1753                                                 else
1754                                                 {
1755                                                         if (blind)
1756                                                         {
1757 #ifdef JP
1758 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1759 #else
1760                                                                 msg_format("%^s mumbles.", m_name);
1761 #endif
1762
1763                                                         }
1764                                                         else
1765                                                         {
1766 #ifdef JP
1767 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥Õ¥¡¥¤¥¢¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
1768 #else
1769                                                                 msg_format("%^s casts a fire ball at %s.", m_name, t_name);
1770 #endif
1771
1772                                                         }
1773                                                 }
1774                                         }
1775                                         else
1776                                         {
1777                                                 mon_fight = TRUE;
1778                                         }
1779                                 }
1780
1781                                 dam = (randint1(rlev * 7 / 2) + 10) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
1782                                 monst_breath_monst(m_idx, y, x, GF_FIRE, dam, 2, FALSE, MS_BALL_FIRE, learnable);
1783
1784                                 break;
1785                         }
1786
1787                         /* RF5_BA_COLD */
1788                         case 128+3:
1789                         {
1790                                 if (known)
1791                                 {
1792                                         if (see_either)
1793                                         {
1794                                                 disturb(1, 0);
1795
1796                                                 if (blind)
1797                                                 {
1798 #ifdef JP
1799 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1800 #else
1801                                                         msg_format("%^s mumbles.", m_name);
1802 #endif
1803
1804                                                 }
1805                                                 else
1806                                                 {
1807 #ifdef JP
1808 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¢¥¤¥¹¡¦¥Ü¡¼¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
1809 #else
1810                                                         msg_format("%^s casts a frost ball at %s.", m_name, t_name);
1811 #endif
1812
1813                                                 }
1814                                         }
1815                                         else
1816                                         {
1817                                                 mon_fight = TRUE;
1818                                         }
1819                                 }
1820
1821                                 dam = (randint1(rlev * 3 / 2) + 10) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
1822                                 monst_breath_monst(m_idx, y, x, GF_COLD, dam, 2, FALSE, MS_BALL_COLD, learnable);
1823
1824                                 break;
1825                         }
1826
1827                         /* RF5_BA_POIS */
1828                         case 128+4:
1829                         {
1830                                 if (known)
1831                                 {
1832                                         if (see_either)
1833                                         {
1834                                                 disturb(1, 0);
1835
1836                                                 if (blind)
1837                                                 {
1838 #ifdef JP
1839 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1840 #else
1841                                                         msg_format("%^s mumbles.", m_name);
1842 #endif
1843
1844                                                 }
1845                                                 else
1846                                                 {
1847 #ifdef JP
1848 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ°½±À¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
1849 #else
1850                                                         msg_format("%^s casts a stinking cloud at %s.", m_name, t_name);
1851 #endif
1852
1853                                                 }
1854                                         }
1855                                         else
1856                                         {
1857                                                 mon_fight = TRUE;
1858                                         }
1859                                 }
1860
1861                                 dam = damroll(12, 2) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
1862                                 monst_breath_monst(m_idx, y, x, GF_POIS, dam, 2, FALSE, MS_BALL_POIS, learnable);
1863
1864                                 break;
1865                         }
1866
1867                         /* RF5_BA_NETH */
1868                         case 128+5:
1869                         {
1870                                 if (known)
1871                                 {
1872                                         if (see_either)
1873                                         {
1874                                                 disturb(1, 0);
1875
1876                                                 if (blind)
1877                                                 {
1878 #ifdef JP
1879 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1880 #else
1881                                                         msg_format("%^s mumbles.", m_name);
1882 #endif
1883
1884                                                 }
1885                                                 else
1886                                                 {
1887 #ifdef JP
1888 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤ÆÃÏ¹öµå¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
1889 #else
1890                                                         msg_format("%^s casts a nether ball at %s.", m_name, t_name);
1891 #endif
1892
1893                                                 }
1894                                         }
1895                                         else
1896                                         {
1897                                                 mon_fight = TRUE;
1898                                         }
1899                                 }
1900
1901                                 dam = 50 + damroll(10, 10) + (rlev * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1));
1902                                 monst_breath_monst(m_idx, y, x, GF_NETHER, dam, 2, FALSE, MS_BALL_NETHER, learnable);
1903
1904                                 break;
1905                         }
1906
1907                         /* RF5_BA_WATE */
1908                         case 128+6:
1909                         {
1910                                 if (known)
1911                                 {
1912                                         if (see_either)
1913                                         {
1914                                                 disturb(1, 0);
1915
1916                                                 if (blind)
1917                                                 {
1918 #ifdef JP
1919 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1920 #else
1921                                                         msg_format("%^s mumbles.", m_name);
1922 #endif
1923
1924                                                 }
1925                                                 else
1926                                                 {
1927 #ifdef JP
1928 msg_format("%^s¤¬%s¤ËÂÐ¤·¤ÆÎ®¤ì¤ë¤è¤¦¤Ê¿È¿¶¤ê¤ò¤·¤¿¡£", m_name, t_name);
1929 #else
1930                                                         msg_format("%^s gestures fluidly at %s.", m_name, t_name);
1931 #endif
1932
1933 #ifdef JP
1934 msg_format("%^s¤Ï±²´¬¤Ë°û¤ß¹þ¤Þ¤ì¤¿¡£", t_name);
1935 #else
1936                                                         msg_format("%^s is engulfed in a whirlpool.", t_name);
1937 #endif
1938
1939                                                 }
1940                                         }
1941                                         else
1942                                         {
1943                                                 mon_fight = TRUE;
1944                                         }
1945                                 }
1946
1947                                 dam = ((r_ptr->flags2 & RF2_POWERFUL) ? randint1(rlev * 3) : randint1(rlev * 2)) + 50;
1948                                 monst_breath_monst(m_idx, y, x, GF_WATER, dam, 4, FALSE, MS_BALL_WATER, learnable);
1949
1950                                 break;
1951                         }
1952
1953                         /* RF5_BA_MANA */
1954                         case 128+7:
1955                         {
1956                                 if (known)
1957                                 {
1958                                         if (see_either)
1959                                         {
1960                                                 disturb(1, 0);
1961
1962                                                 if (blind)
1963                                                 {
1964 #ifdef JP
1965 msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
1966 #else
1967                                                         msg_format("%^s mumbles powerfully.", m_name);
1968 #endif
1969
1970                                                 }
1971                                                 else
1972                                                 {
1973 #ifdef JP
1974 msg_format("%^s¤¬%s¤ËÂÐ¤·¤ÆËâÎÏ¤ÎÍò¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name, t_name);
1975 #else
1976                                                         msg_format("%^s invokes a mana storm upon %s.", m_name, t_name);
1977 #endif
1978
1979                                                 }
1980                                         }
1981                                         else
1982                                         {
1983                                                 mon_fight = TRUE;
1984                                         }
1985                                 }
1986
1987                                 dam = (rlev * 4) + 50 + damroll(10, 10);
1988                                 monst_breath_monst(m_idx, y, x, GF_MANA, dam, 4, FALSE, MS_BALL_MANA, learnable);
1989
1990                                 break;
1991                         }
1992
1993                         /* RF5_BA_DARK */
1994                         case 128+8:
1995                         {
1996                                 if (known)
1997                                 {
1998                                         if (see_either)
1999                                         {
2000                                                 disturb(1, 0);
2001
2002                                                 if (blind)
2003                                                 {
2004 #ifdef JP
2005 msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2006 #else
2007                                                         msg_format("%^s mumbles powerfully.", m_name);
2008 #endif
2009
2010                                                 }
2011                                                 else
2012                                                 {
2013 #ifdef JP
2014 msg_format("%^s¤¬%s¤ËÂÐ¤·¤Æ°Å¹õ¤ÎÍò¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name, t_name);
2015 #else
2016                                                         msg_format("%^s invokes a darkness storm upon %s.", m_name, t_name);
2017 #endif
2018
2019                                                 }
2020                                         }
2021                                         else
2022                                         {
2023                                                 mon_fight = TRUE;
2024                                         }
2025                                 }
2026
2027                                 dam = (rlev * 4) + 50 + damroll(10, 10);
2028                                 monst_breath_monst(m_idx, y, x, GF_DARK, dam, 4, FALSE, MS_BALL_DARK, learnable);
2029
2030                                 break;
2031                         }
2032
2033                         /* RF5_DRAIN_MANA */
2034                         case 128+9:
2035                         {
2036                                 /* Attack power */
2037                                 int power = (randint1(rlev) / 2) + 1;
2038
2039                                 if (see_m)
2040                                 {
2041                                         /* Basic message */
2042 #ifdef JP
2043 msg_format("%^s¤ÏÀº¿À¥¨¥Í¥ë¥®¡¼¤ò%s¤«¤éµÛ¤¤¤È¤Ã¤¿¡£", m_name, t_name);
2044 #else
2045                                         msg_format("%^s draws psychic energy from %s.", m_name, t_name);
2046 #endif
2047
2048                                 }
2049
2050                                 /* Heal the monster */
2051                                 if (m_ptr->hp < m_ptr->maxhp)
2052                                 {
2053                                         if (!tr_ptr->flags4 && !tr_ptr->flags5 && !tr_ptr->flags6)
2054                                         {
2055                                                 if (see_both)
2056                                                 {
2057 #ifdef JP
2058 msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2059 #else
2060                                                         msg_format("%^s is unaffected!", t_name);
2061 #endif
2062
2063                                                 }
2064                                         }
2065                                         else
2066                                         {
2067                                                 /* Heal */
2068                                                 m_ptr->hp += 6 * power;
2069                                                 if (m_ptr->hp > m_ptr->maxhp) m_ptr->hp = m_ptr->maxhp;
2070
2071                                                 /* Redraw (later) if needed */
2072                                                 if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
2073                                                 if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
2074
2075                                                 /* Special message */
2076                                                 if (see_m)
2077                                                 {
2078 #ifdef JP
2079 msg_format("%^s¤Ïµ¤Ê¬¤¬ÎÉ¤µ¤½¤¦¤À¡£", m_name);
2080 #else
2081                                                         msg_format("%^s appears healthier.", m_name);
2082 #endif
2083
2084                                                 }
2085                                         }
2086                                 }
2087
2088                                 wake_up = TRUE;
2089
2090                                 break;
2091                         }
2092
2093                         /* RF5_MIND_BLAST */
2094                         case 128+10:
2095                         {
2096                                 if (see_m)
2097                                 {
2098 #ifdef JP
2099 msg_format("%^s¤Ï%s¤ò¤¸¤Ã¤ÈâË¤ó¤À", m_name, t_name);
2100 #else
2101                                         msg_format("%^s gazes intently at %s.", m_name, t_name);
2102 #endif
2103
2104                                 }
2105
2106                                 dam = damroll(7, 7);
2107                                 /* Attempt a saving throw */
2108                                 if ((tr_ptr->flags1 & RF1_UNIQUE) ||
2109                                          (tr_ptr->flags3 & RF3_NO_CONF) ||
2110                                          (tr_ptr->flags3 & RF3_RES_ALL) ||
2111                                          (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10))
2112                                 {
2113                                         /* No obvious effect */
2114                                         if (see_both)
2115                                         {
2116                                                 /* Memorize a flag */
2117                                                 if (tr_ptr->flags3 & (RF3_RES_ALL))
2118                                                 {
2119                                                         tr_ptr->r_flags3 |= (RF3_RES_ALL);
2120                                                 }
2121                                                 else if (tr_ptr->flags3 & (RF3_NO_CONF))
2122                                                 {
2123                                                         tr_ptr->r_flags3 |= (RF3_NO_CONF);
2124                                                 }
2125
2126 #ifdef JP
2127 msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2128 #else
2129                                                 msg_format("%^s is unaffected!", t_name);
2130 #endif
2131
2132                                         }
2133                                 }
2134                                 else
2135                                 {
2136                                         if (see_t)
2137                                         {
2138 #ifdef JP
2139 msg_format("%^s¤ÏÀº¿À¹¶·â¤ò¿©¤é¤Ã¤¿¡£", t_name);
2140 #else
2141                                                 msg_format("%^s is blasted by psionic energy.", t_name);
2142 #endif
2143
2144                                         }
2145
2146                                         t_ptr->confused += randint0(4) + 4;
2147
2148 #ifdef JP
2149 mon_take_hit_mon(FALSE, t_idx, dam, &fear, "¤ÎÀº¿À¤ÏÊø²õ¤·¡¢ÆùÂÎ¤ÏÈ´¤±¶õ¤È¤Ê¤Ã¤¿¡£", m_idx);
2150 #else
2151                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, " collapses, a mindless husk.", m_idx);
2152 #endif
2153
2154                                 }
2155
2156                                 wake_up = TRUE;
2157
2158                                 break;
2159                         }
2160
2161                         /* RF5_BRAIN_SMASH */
2162                         case 128+11:
2163                         {
2164                                 if (see_m)
2165                                 {
2166 #ifdef JP
2167 msg_format("%^s¤Ï%s¤ò¤¸¤Ã¤ÈâË¤ó¤À", m_name, t_name);
2168 #else
2169                                         msg_format("%^s gazes intently at %s.", m_name, t_name);
2170 #endif
2171
2172                                 }
2173
2174                                 dam = damroll(12, 12);
2175                                 /* Attempt a saving throw */
2176                                 if ((tr_ptr->flags1 & RF1_UNIQUE) ||
2177                                          (tr_ptr->flags3 & RF3_NO_CONF) ||
2178                                          (tr_ptr->flags3 & RF3_RES_ALL) ||
2179                                          (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10))
2180                                 {
2181                                         /* No obvious effect */
2182                                         if (see_both)
2183                                         {
2184                                                 /* Memorize a flag */
2185                                                 if (tr_ptr->flags3 & (RF3_RES_ALL))
2186                                                 {
2187                                                         tr_ptr->r_flags3 |= (RF3_RES_ALL);
2188                                                 }
2189                                                 else if (tr_ptr->flags3 & (RF3_NO_CONF))
2190                                                 {
2191                                                         tr_ptr->r_flags3 |= (RF3_NO_CONF);
2192                                                 }
2193
2194 #ifdef JP
2195 msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2196 #else
2197                                                 msg_format("%^s is unaffected!", t_name);
2198 #endif
2199
2200                                         }
2201                                 }
2202                                 else
2203                                 {
2204                                         if (see_t)
2205                                         {
2206 #ifdef JP
2207 msg_format("%^s¤ÏÀº¿À¹¶·â¤ò¿©¤é¤Ã¤¿¡£", t_name);
2208 #else
2209                                                 msg_format("%^s is blasted by psionic energy.", t_name);
2210 #endif
2211
2212                                         }
2213
2214                                         t_ptr->confused += randint0(4) + 4;
2215                                         t_ptr->slow = MIN(200, t_ptr->slow + 10);
2216                                         t_ptr->stunned += randint0(4) + 4;
2217
2218 #ifdef JP
2219 mon_take_hit_mon(FALSE, t_idx, dam, &fear, "¤ÎÀº¿À¤ÏÊø²õ¤·¡¢ÆùÂÎ¤ÏÈ´¤±¶õ¤È¤Ê¤Ã¤¿¡£", m_idx);
2220 #else
2221                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, " collapses, a mindless husk.", m_idx);
2222 #endif
2223
2224                                 }
2225
2226                                 wake_up = TRUE;
2227
2228                                 break;
2229                         }
2230
2231                         /* RF5_CAUSE_1 */
2232                         case 128+12:
2233                         {
2234                                 if (known)
2235                                 {
2236                                         if (see_m)
2237                                         {
2238 #ifdef JP
2239 msg_format("%^s¤Ï%s¤ò»Ø¤µ¤·¤Æ¼ö¤¤¤ò¤«¤±¤¿¡£", m_name, t_name);
2240 #else
2241                                                 msg_format("%^s points at %s and curses.", m_name, t_name);
2242 #endif
2243
2244                                         }
2245                                         else
2246                                         {
2247                                                 mon_fight = TRUE;
2248                                         }
2249                                 }
2250
2251                                 dam = damroll(3, 8);
2252                                 if ((randint0(100 + rlev/2) < (tr_ptr->level + 35)) ||
2253                                          (tr_ptr->flags3 & RF3_RES_ALL))
2254                                 {
2255                                         /* Memorize a flag */
2256                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
2257                                         {
2258                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
2259                                         }
2260 #ifdef JP
2261 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
2262 #else
2263                                         if (see_both) msg_format("%^s resists!", t_name);
2264 #endif
2265
2266                                 }
2267                                 else
2268                                 {
2269                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2270                                 }
2271
2272                                 wake_up = TRUE;
2273
2274                                 break;
2275                         }
2276
2277                         /* RF5_CAUSE_2 */
2278                         case 128+13:
2279                         {
2280                                 if (known)
2281                                 {
2282                                         if (see_m)
2283                                         {
2284 #ifdef JP
2285 msg_format("%^s¤Ï%s¤ò»Ø¤µ¤·¤Æ¶²¤í¤·¤²¤Ë¼ö¤¤¤ò¤«¤±¤¿¡£", m_name, t_name);
2286 #else
2287                                                 msg_format("%^s points at %s and curses horribly.", m_name, t_name);
2288 #endif
2289
2290                                         }
2291                                         else
2292                                         {
2293                                                 mon_fight = TRUE;
2294                                         }
2295                                 }
2296
2297                                 dam = damroll(8, 8);
2298                                 if ((randint0(100 + rlev/2) < (tr_ptr->level + 35)) ||
2299                                          (tr_ptr->flags3 & RF3_RES_ALL))
2300                                 {
2301                                         /* Memorize a flag */
2302                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
2303                                         {
2304                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
2305                                         }
2306 #ifdef JP
2307 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
2308 #else
2309                                         if (see_both) msg_format("%^s resists!", t_name);
2310 #endif
2311
2312                                 }
2313                                 else
2314                                 {
2315                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2316
2317                                 }
2318
2319                                 wake_up = TRUE;
2320
2321                                 break;
2322                         }
2323
2324                         /* RF5_CAUSE_3 */
2325                         case 128+14:
2326                         {
2327                                 if (known)
2328                                 {
2329                                         if (see_m)
2330                                         {
2331 #ifdef JP
2332 msg_format("%^s¤Ï%s¤ò»Ø¤µ¤·¡¢¶²¤í¤·¤²¤Ë¼öÊ¸¤ò¾§¤¨¤¿¡ª", m_name, t_name);
2333 #else
2334                                                 msg_format("%^s points at %s, incanting terribly!", m_name, t_name);
2335 #endif
2336
2337                                         }
2338                                         else
2339                                         {
2340                                                 mon_fight = TRUE;
2341                                         }
2342                                 }
2343
2344                                 dam = damroll(10, 15);
2345                                 if ((randint0(100 + rlev/2) < (tr_ptr->level + 35)) ||
2346                                          (tr_ptr->flags3 & RF3_RES_ALL))
2347                                 {
2348                                         /* Memorize a flag */
2349                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
2350                                         {
2351                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
2352                                         }
2353 #ifdef JP
2354 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
2355 #else
2356                                         if (see_both) msg_format("%^s resists!", t_name);
2357 #endif
2358
2359                                 }
2360                                 else
2361                                 {
2362                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2363                                 }
2364
2365                                 wake_up = TRUE;
2366
2367                                 break;
2368                         }
2369
2370                         /* RF5_CAUSE_4 */
2371                         case 128+15:
2372                         {
2373                                 if (known)
2374                                 {
2375                                         if (see_m)
2376                                         {
2377 #ifdef JP
2378 msg_format("%^s¤¬%s¤ÎÈë¹¦¤òÆÍ¤¤¤Æ¡¢¡Ö¤ªÁ°¤Ï´û¤Ë»à¤ó¤Ç¤¤¤ë¡×¤È¶«¤ó¤À¡£", m_name, t_name);
2379 #else
2380                                                 msg_format("%^s points at %s, screaming the word, 'DIE!'", m_name, t_name);
2381 #endif
2382
2383                                         }
2384                                         else
2385                                         {
2386                                                 mon_fight = TRUE;
2387                                         }
2388                                 }
2389
2390                                 dam = damroll(15, 15);
2391                                 if (((randint0(100 + rlev/2) < (tr_ptr->level + 35)) && (m_ptr->r_idx != MON_KENSHIROU)) ||
2392                                          (tr_ptr->flags3 & RF3_RES_ALL))
2393                                 {
2394                                         /* Memorize a flag */
2395                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
2396                                         {
2397                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
2398                                         }
2399 #ifdef JP
2400 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
2401 #else
2402                                         if (see_both) msg_format("%^s resists!", t_name);
2403 #endif
2404
2405                                 }
2406                                 else
2407                                 {
2408                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2409                                 }
2410
2411                                 wake_up = TRUE;
2412
2413                                 break;
2414                         }
2415
2416                         /* RF5_BO_ACID */
2417                         case 128+16:
2418                         {
2419                                 if (known)
2420                                 {
2421                                         if (see_either)
2422                                         {
2423 #ifdef JP
2424 msg_format("%s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¢¥·¥Ã¥É¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2425 #else
2426                                                 msg_format("%^s casts an acid bolt at %s.", m_name, t_name);
2427 #endif
2428
2429                                         }
2430                                         else
2431                                         {
2432                                                 mon_fight = TRUE;
2433                                         }
2434                                 }
2435
2436                                 dam = (damroll(7, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2437                                 monst_bolt_monst(m_idx, y, x, GF_ACID,
2438                                         dam, MS_BOLT_ACID, learnable);
2439
2440                                 break;
2441                         }
2442
2443                         /* RF5_BO_ELEC */
2444                         case 128+17:
2445                         {
2446                                 if (known)
2447                                 {
2448                                         if (see_either)
2449                                         {
2450 #ifdef JP
2451 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥µ¥ó¥À¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2452 #else
2453                                                 msg_format("%^s casts a lightning bolt at %s.", m_name, t_name);
2454 #endif
2455
2456                                         }
2457                                         else
2458                                         {
2459                                                 mon_fight = TRUE;
2460                                         }
2461                                 }
2462
2463                                 dam = (damroll(4, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2464                                 monst_bolt_monst(m_idx, y, x, GF_ELEC,
2465                                         dam, MS_BOLT_ELEC, learnable);
2466
2467                                 break;
2468                         }
2469
2470                         /* RF5_BO_FIRE */
2471                         case 128+18:
2472                         {
2473                                 if (known)
2474                                 {
2475                                         if (see_either)
2476                                         {
2477 #ifdef JP
2478 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥Õ¥¡¥¤¥¢¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2479 #else
2480                                                 msg_format("%^s casts a fire bolt at %s.", m_name, t_name);
2481 #endif
2482
2483                                         }
2484                                         else
2485                                         {
2486                                                 mon_fight = TRUE;
2487                                         }
2488                                 }
2489
2490                                 dam = (damroll(9, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2491                                 monst_bolt_monst(m_idx, y, x, GF_FIRE,
2492                                         dam, MS_BOLT_FIRE, learnable);
2493
2494                                 break;
2495                         }
2496
2497                         /* RF5_BO_COLD */
2498                         case 128+19:
2499                         {
2500                                 if (known)
2501                                 {
2502                                         if (see_either)
2503                                         {
2504 #ifdef JP
2505 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¢¥¤¥¹¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2506 #else
2507                                                 msg_format("%^s casts a frost bolt at %s.", m_name, t_name);
2508 #endif
2509
2510                                         }
2511                                         else
2512                                         {
2513                                                 mon_fight = TRUE;
2514                                         }
2515                                 }
2516
2517                                 dam = (damroll(6, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2518                                 monst_bolt_monst(m_idx, y, x, GF_COLD,
2519                                         dam, MS_BOLT_COLD, learnable);
2520
2521                                 break;
2522                         }
2523
2524                         /* RF5_BA_LITE */
2525                         case 128+20:
2526                         {
2527                                 if (known)
2528                                 {
2529                                         if (see_either)
2530                                         {
2531                                                 disturb(1, 0);
2532
2533                                                 if (blind)
2534                                                 {
2535 #ifdef JP
2536 msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2537 #else
2538                                                         msg_format("%^s mumbles powerfully.", m_name);
2539 #endif
2540
2541                                                 }
2542                                                 else
2543                                                 {
2544 #ifdef JP
2545 msg_format("%^s¤¬%s¤ËÂÐ¤·¤Æ¥¹¥¿¡¼¥Ð¡¼¥¹¥È¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name, t_name);
2546 #else
2547                                                         msg_format("%^s invokes a starburst upon %s.", m_name, t_name);
2548 #endif
2549
2550                                                 }
2551                                         }
2552                                         else
2553                                         {
2554                                                 mon_fight = TRUE;
2555                                         }
2556                                 }
2557
2558                                 dam = (rlev * 4) + 50 + damroll(10, 10);
2559                                 monst_breath_monst(m_idx, y, x, GF_LITE, dam, 4, FALSE, MS_STARBURST, learnable);
2560
2561                                 break;
2562                         }
2563
2564                         /* RF5_BO_NETH */
2565                         case 128+21:
2566                         {
2567                                 if (known)
2568                                 {
2569                                         if (see_either)
2570                                         {
2571 #ifdef JP
2572 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤ÆÃÏ¹ö¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2573 #else
2574                                                 msg_format("%^s casts a nether bolt at %s.", m_name, t_name);
2575 #endif
2576
2577                                         }
2578                                         else
2579                                         {
2580                                                 mon_fight = TRUE;
2581                                         }
2582                                 }
2583
2584                                 dam = 30 + damroll(5, 5) + (rlev * 4) / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3);
2585                                 monst_bolt_monst(m_idx, y, x, GF_NETHER,
2586                                         dam, MS_BOLT_NETHER, learnable);
2587
2588                                 break;
2589                         }
2590
2591                         /* RF5_BO_WATE */
2592                         case 128+22:
2593                         {
2594                                 if (known)
2595                                 {
2596                                         if (see_either)
2597                                         {
2598 #ifdef JP
2599 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¦¥©¡¼¥¿¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2600 #else
2601                                                 msg_format("%^s casts a water bolt at %s.", m_name, t_name);
2602 #endif
2603
2604                                         }
2605                                         else
2606                                         {
2607                                                 mon_fight = TRUE;
2608                                         }
2609                                 }
2610
2611                                 dam = damroll(10, 10) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
2612                                 monst_bolt_monst(m_idx, y, x, GF_WATER,
2613                                         dam, MS_BOLT_WATER, learnable);
2614
2615                                 break;
2616                         }
2617
2618                         /* RF5_BO_MANA */
2619                         case 128+23:
2620                         {
2621                                 if (known)
2622                                 {
2623                                         if (see_either)
2624                                         {
2625 #ifdef JP
2626 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤ÆËâÎÏ¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2627 #else
2628                                                 msg_format("%^s casts a mana bolt at %s.", m_name, t_name);
2629 #endif
2630
2631                                         }
2632                                         else
2633                                         {
2634                                                 mon_fight = TRUE;
2635                                         }
2636                                 }
2637
2638                                 dam = randint1(rlev * 7 / 2) + 50;
2639                                 monst_bolt_monst(m_idx, y, x, GF_MANA,
2640                                         dam, MS_BOLT_MANA, learnable);
2641
2642                                 break;
2643                         }
2644
2645                         /* RF5_BO_PLAS */
2646                         case 128+24:
2647                         {
2648                                 if (known)
2649                                 {
2650                                         if (see_either)
2651                                         {
2652 #ifdef JP
2653 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥×¥é¥º¥Þ¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2654 #else
2655                                                 msg_format("%^s casts a plasma bolt at %s.", m_name, t_name);
2656 #endif
2657
2658                                         }
2659                                         else
2660                                         {
2661                                                 mon_fight = TRUE;
2662                                         }
2663                                 }
2664
2665                                 dam = 10 + damroll(8, 7) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
2666                                 monst_bolt_monst(m_idx, y, x, GF_PLASMA,
2667                                         dam, MS_BOLT_PLASMA, learnable);
2668
2669                                 break;
2670                         }
2671
2672                         /* RF5_BO_ICEE */
2673                         case 128+25:
2674                         {
2675                                 if (known)
2676                                 {
2677                                         if (see_either)
2678                                         {
2679 #ifdef JP
2680 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¶Ë´¨¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2681 #else
2682                                                 msg_format("%^s casts an ice bolt at %s.", m_name, t_name);
2683 #endif
2684
2685                                         }
2686                                         else
2687                                         {
2688                                                 mon_fight = TRUE;
2689                                         }
2690                                 }
2691
2692                                 dam = damroll(6, 6) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
2693                                 monst_bolt_monst(m_idx, y, x, GF_ICE,
2694                                         dam, MS_BOLT_ICE, learnable);
2695
2696                                 break;
2697                         }
2698
2699                         /* RF5_MISSILE */
2700                         case 128+26:
2701                         {
2702                                 if (known)
2703                                 {
2704                                         if (see_either)
2705                                         {
2706 #ifdef JP
2707 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥Þ¥¸¥Ã¥¯¡¦¥ß¥µ¥¤¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2708 #else
2709                                                 msg_format("%^s casts a magic missile at %s.", m_name, t_name);
2710 #endif
2711
2712                                         }
2713                                         else
2714                                         {
2715                                                 mon_fight = TRUE;
2716                                         }
2717                                 }
2718
2719                                 dam = damroll(2, 6) + (rlev / 3);
2720                                 monst_bolt_monst(m_idx, y, x, GF_MISSILE,
2721                                         dam, MS_MAGIC_MISSILE, learnable);
2722
2723                                 break;
2724                         }
2725
2726                         /* RF5_SCARE */
2727                         case 128+27:
2728                         {
2729                                 if (known)
2730                                 {
2731                                         if (see_either)
2732                                         {
2733 #ifdef JP
2734 msg_format("%^s¤¬¶²¤í¤·¤²¤Ê¸¸³Ð¤òºî¤ê½Ð¤·¤¿¡£", m_name, t_name);
2735 #else
2736                                                 msg_format("%^s casts a fearful illusion in front of %s.", m_name, t_name);
2737 #endif
2738
2739                                         }
2740                                         else
2741                                         {
2742                                                 mon_fight = TRUE;
2743                                         }
2744                                 }
2745
2746                                 if (tr_ptr->flags3 & RF3_NO_FEAR)
2747                                 {
2748 #ifdef JP
2749 if (see_t) msg_format("%^s¤Ï¶²ÉÝ¤ò´¶¤¸¤Ê¤¤¡£", t_name);
2750 #else
2751                                         if (see_t) msg_format("%^s refuses to be frightened.", t_name);
2752 #endif
2753
2754                                 }
2755                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2756                                 {
2757 #ifdef JP
2758 if (see_t) msg_format("%^s¤Ï¶²ÉÝ¤ò´¶¤¸¤Ê¤¤¡£", t_name);
2759 #else
2760                                         if (see_t) msg_format("%^s refuses to be frightened.", t_name);
2761 #endif
2762
2763                                 }
2764                                 else
2765                                 {
2766                                         if (!t_ptr->monfear) fear = TRUE;
2767
2768                                         t_ptr->monfear += randint0(4) + 4;
2769                                 }
2770
2771                                 wake_up = TRUE;
2772
2773                                 break;
2774                         }
2775
2776                         /* RF5_BLIND */
2777                         case 128+28:
2778                         {
2779                                 if (known)
2780                                 {
2781                                         if (see_either)
2782                                         {
2783 #ifdef JP
2784 msg_format("%s¤Ï¼öÊ¸¤ò¾§¤¨¤Æ%s¤ÎÌÜ¤ò¾Æ¤ÉÕ¤«¤»¤¿¡£", m_name, t_name);
2785 #else
2786                                                 msg_format("%^s casts a spell, burning %s%s eyes.", m_name, t_name,
2787                                                                           (streq(t_name, "it") ? "s" : "'s"));
2788 #endif
2789
2790                                         }
2791                                         else
2792                                         {
2793                                                 mon_fight = TRUE;
2794                                         }
2795                                 }
2796
2797                                 /* Simulate blindness with confusion */
2798                                 if (tr_ptr->flags3 & RF3_NO_CONF)
2799                                 {
2800 #ifdef JP
2801 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2802 #else
2803                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2804 #endif
2805
2806                                 }
2807                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2808                                 {
2809 #ifdef JP
2810 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2811 #else
2812                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2813 #endif
2814
2815                                 }
2816                                 else
2817                                 {
2818 #ifdef JP
2819 if (see_t)   msg_format("%^s¤ÏÌÜ¤¬¸«¤¨¤Ê¤¯¤Ê¤Ã¤¿¡ª ", t_name);
2820 #else
2821                                         if (see_t) msg_format("%^s is blinded!", t_name);
2822 #endif
2823
2824
2825                                         t_ptr->confused += 12 + (byte)randint0(4);
2826                                 }
2827
2828                                 wake_up = TRUE;
2829
2830                                 break;
2831                         }
2832
2833                         /* RF5_CONF */
2834                         case 128+29:
2835                         {
2836                                 if (known)
2837                                 {
2838                                         if (see_either)
2839                                         {
2840 #ifdef JP
2841 msg_format("%^s¤¬%s¤ÎÁ°¤Ë¸¸ÏÇÅª¤Ê¸¸¤ò¤Ä¤¯¤ê½Ð¤·¤¿¡£", m_name, t_name);
2842 #else
2843                                                 msg_format("%^s casts a mesmerizing illusion in front of %s.", m_name, t_name);
2844 #endif
2845
2846                                         }
2847                                         else
2848                                         {
2849                                                 mon_fight = TRUE;
2850                                         }
2851                                 }
2852
2853                                 if (tr_ptr->flags3 & RF3_NO_CONF)
2854                                 {
2855 #ifdef JP
2856 if (see_t) msg_format("%^s¤ÏÏÇ¤ï¤µ¤ì¤Ê¤«¤Ã¤¿¡£", t_name);
2857 #else
2858                                         if (see_t) msg_format("%^s disbelieves the feeble spell.", t_name);
2859 #endif
2860
2861                                 }
2862                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2863                                 {
2864 #ifdef JP
2865 if (see_t) msg_format("%^s¤ÏÏÇ¤ï¤µ¤ì¤Ê¤«¤Ã¤¿¡£", t_name);
2866 #else
2867                                         if (see_t) msg_format("%^s disbelieves the feeble spell.", t_name);
2868 #endif
2869
2870                                 }
2871                                 else
2872                                 {
2873 #ifdef JP
2874 if (see_t) msg_format("%^s¤Ïº®Íð¤·¤¿¤è¤¦¤À¡£", t_name);
2875 #else
2876                                         if (see_t) msg_format("%^s seems confused.", t_name);
2877 #endif
2878
2879
2880                                         t_ptr->confused += 12 + (byte)randint0(4);
2881                                 }
2882
2883                                 wake_up = TRUE;
2884
2885                                 break;
2886                         }
2887
2888                         /* RF5_SLOW */
2889                         case 128+30:
2890                         {
2891                                 if (known)
2892                                 {
2893                                         if (see_either)
2894                                         {
2895 #ifdef JP
2896 msg_format("%s¤¬%s¤Î¶ÚÆù¤«¤éÎÏ¤òµÛ¤¤¤È¤Ã¤¿¡£", m_name, t_name);
2897 #else
2898                                                 msg_format("%^s drains power from %s%s muscles.", m_name, t_name,
2899                                                                           (streq(t_name, "it") ? "s" : "'s"));
2900 #endif
2901
2902                                         }
2903                                         else
2904                                         {
2905                                                 mon_fight = TRUE;
2906                                         }
2907                                 }
2908
2909                                 if (tr_ptr->flags1 & RF1_UNIQUE)
2910                                 {
2911 #ifdef JP
2912 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2913 #else
2914                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2915 #endif
2916
2917                                 }
2918                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2919                                 {
2920 #ifdef JP
2921 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2922 #else
2923                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2924 #endif
2925
2926                                 }
2927                                 else
2928                                 {
2929                                         if (!t_ptr->slow)
2930                                         {
2931 #ifdef JP
2932 if (see_t) msg_format("%s¤ÎÆ°¤¤¬ÃÙ¤¯¤Ê¤Ã¤¿¡£", t_name);
2933 #else
2934                                         if (see_t) msg_format("%^s starts moving slower.", t_name);
2935 #endif
2936                                         }
2937
2938                                         t_ptr->slow = MIN(200, t_ptr->slow + 50);
2939                                 }
2940
2941                                 wake_up = TRUE;
2942
2943                                 break;
2944                         }
2945
2946                         /* RF5_HOLD */
2947                         case 128+31:
2948                         {
2949                                 if (known)
2950                                 {
2951                                         if (see_either)
2952                                         {
2953 #ifdef JP
2954 msg_format("%^s¤Ï%s¤ò¤¸¤Ã¤È¸«¤Ä¤á¤¿¡£", m_name, t_name);
2955 #else
2956                                                 msg_format("%^s stares intently at %s.", m_name, t_name);
2957 #endif
2958
2959                                         }
2960                                         else
2961                                         {
2962                                                 mon_fight = TRUE;
2963                                         }
2964                                 }
2965
2966                                 if ((tr_ptr->flags1 & RF1_UNIQUE) ||
2967                                          (tr_ptr->flags3 & RF3_NO_STUN))
2968                                 {
2969 #ifdef JP
2970 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2971 #else
2972                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2973 #endif
2974
2975                                 }
2976                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2977                                 {
2978 #ifdef JP
2979 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2980 #else
2981                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2982 #endif
2983
2984                                 }
2985                                 else
2986                                 {
2987 #ifdef JP
2988 if (see_t) msg_format("%^s¤ÏËãáã¤·¤¿¡ª", t_name);
2989 #else
2990                                         if (see_t) msg_format("%^s is paralyzed!", t_name);
2991 #endif
2992
2993
2994                                         t_ptr->stunned += randint1(4) + 4;
2995                                 }
2996
2997                                 wake_up = TRUE;
2998
2999                                 break;
3000                         }
3001
3002
3003                         /* RF6_HASTE */
3004                         case 160+0:
3005                         {
3006                                 if (known)
3007                                 {
3008                                         if (see_m)
3009                                         {
3010 #ifdef JP
3011 msg_format("%^s¤¬¼«Ê¬¤ÎÂÎ¤ËÇ°¤òÁ÷¤Ã¤¿¡£", m_name, m_poss);
3012 #else
3013                                                 msg_format("%^s concentrates on %s body.", m_name, m_poss);
3014 #endif
3015
3016                                         }
3017                                         else
3018                                         {
3019                                                 mon_fight = TRUE;
3020                                         }
3021                                 }
3022
3023                                 /* Allow quick speed increases to base+10 */
3024                                 if (!m_ptr->fast)
3025                                 {
3026 #ifdef JP
3027 if (see_m) msg_format("%^s¤ÎÆ°¤¤¬Â®¤¯¤Ê¤Ã¤¿¡£", m_name);
3028 #else
3029                                         if (see_m) msg_format("%^s starts moving faster.", m_name);
3030 #endif
3031
3032                                 }
3033                                 m_ptr->fast = MIN(200, m_ptr->fast + 100);
3034                                 if (p_ptr->riding == m_idx) p_ptr->update |= PU_BONUS;
3035                                 break;
3036                         }
3037
3038                         /* RF6_HAND_DOOM */
3039                         case 160+1:
3040                         {
3041                                 if (known)
3042                                 {
3043                                         if (see_m)
3044                                         {
3045 #ifdef JP
3046 msg_format("%^s¤¬%s¤Ë<ÇËÌÇ¤Î¼ê>¤òÊü¤Ã¤¿¡ª", m_name, t_name);
3047 #else
3048                                                 msg_format("%^s invokes the Hand of Doom upon %s!", m_name, t_name);
3049 #endif
3050
3051                                         }
3052                                         else
3053                                         {
3054                                                 mon_fight = TRUE;
3055                                         }
3056                                 }
3057
3058                                 if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flags3 & RF3_RES_ALL))
3059                                 {
3060                                         /* Memorize a flag */
3061                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
3062                                         {
3063                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
3064                                         }
3065 #ifdef JP
3066 if (see_both) msg_format("¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª", t_name);
3067 #else
3068                                         if (see_both) msg_format("^%s is unaffected!", t_name);
3069 #endif
3070
3071                                 }
3072                                 else
3073                                 {
3074                                         if ((r_ptr->level + randint1(20)) >
3075                                                 (tr_ptr->level + 10 + randint1(20)))
3076                                         {
3077                                                 t_ptr->hp = t_ptr->hp -
3078                                                   (((s32b)((40 + randint1(20)) * t_ptr->hp)) / 100);
3079
3080                                                 if (t_ptr->hp < 1) t_ptr->hp = 1;
3081                                         }
3082                                         else
3083                                         {
3084 #ifdef JP
3085 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
3086 #else
3087                                                 if (see_both) msg_format("%^s resists!", t_name);
3088 #endif
3089
3090                                         }
3091                                 }
3092
3093                                 wake_up = TRUE;
3094
3095                                 break;
3096                         }
3097
3098                         /* RF6_HEAL */
3099                         case 160+2:
3100                         {
3101                                 if (known)
3102                                 {
3103                                         if (see_m)
3104                                         {
3105 #ifdef JP
3106 msg_format("%^s¤Ï¼«Ê¬¤Î½ý¤ËÇ°¤ò½¸Ãæ¤·¤¿¡£", m_name);
3107 #else
3108                                                 msg_format("%^s concentrates on %s wounds.", m_name, m_poss);
3109 #endif
3110
3111                                         }
3112                                         else
3113                                         {
3114                                                 mon_fight = TRUE;
3115                                         }
3116                                 }
3117
3118                                 /* Heal some */
3119                                 m_ptr->hp += (rlev * 6);
3120
3121                                 /* Fully healed */
3122                                 if (m_ptr->hp >= m_ptr->maxhp)
3123                                 {
3124                                         /* Fully healed */
3125                                         m_ptr->hp = m_ptr->maxhp;
3126
3127                                         if (known)
3128                                         {
3129                                                 if (see_m)
3130                                                 {
3131 #ifdef JP
3132 msg_format("%^s¤Ï´°Á´¤Ë¼£¤Ã¤¿¡ª", m_name);
3133 #else
3134                                                         msg_format("%^s looks completely healed!", m_name);
3135 #endif
3136
3137                                                 }
3138                                                 else
3139                                                 {
3140                                                         mon_fight = TRUE;
3141                                                 }
3142                                         }
3143                                 }
3144
3145                                 /* Partially healed */
3146                                 else if (known)
3147                                 {
3148                                         if (see_m)
3149                                         {
3150 #ifdef JP
3151 msg_format("%^s¤ÏÂÎÎÏ¤ò²óÉü¤·¤¿¤è¤¦¤À¡£", m_name);
3152 #else
3153                                                 msg_format("%^s looks healthier.", m_name);
3154 #endif
3155
3156                                         }
3157                                         else
3158                                         {
3159                                                 mon_fight = TRUE;
3160                                         }
3161                                 }
3162
3163                                 /* Redraw (later) if needed */
3164                                 if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
3165                                 if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
3166
3167                                 /* Cancel fear */
3168                                 if (m_ptr->monfear)
3169                                 {
3170                                         /* Cancel fear */
3171                                         m_ptr->monfear = 0;
3172
3173                                         /* Message */
3174 #ifdef JP
3175 if (see_m) msg_format("%^s¤ÏÍ¦µ¤¤ò¼è¤êÌá¤·¤¿¡£", m_name);
3176 #else
3177                                         if (see_m) msg_format("%^s recovers %s courage.", m_name, m_poss);
3178 #endif
3179
3180                                 }
3181
3182                                 break;
3183                         }
3184
3185                         /* RF6_INVULNER */
3186                         case 160+3:
3187                         {
3188                                 if (known)
3189                                 {
3190                                         if (see_m)
3191                                         {
3192                                                 disturb(1, 0);
3193 #ifdef JP
3194 msg_format("%s¤ÏÌµ½ý¤Îµå¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3195 #else
3196                                                 msg_format("%^s casts a Globe of Invulnerability.", m_name);
3197 #endif
3198
3199                                         }
3200                                         else
3201                                         {
3202                                                 mon_fight = TRUE;
3203                                         }
3204                                 }
3205
3206                                 if (!m_ptr->invulner) m_ptr->invulner = randint1(4) + 4;
3207
3208                                 if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
3209                                 if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
3210                                 break;
3211                         }
3212
3213                         /* RF6_BLINK */
3214                         case 160+4:
3215                         {
3216                                 if (see_m)
3217                                 {
3218 #ifdef JP
3219 msg_format("%^s¤¬½Ö»þ¤Ë¾Ã¤¨¤¿¡£", m_name);
3220 #else
3221                                         msg_format("%^s blinks away.", m_name);
3222 #endif
3223
3224                                 }
3225
3226                                 teleport_away(m_idx, 10, FALSE);
3227
3228                                 break;
3229                         }
3230
3231                         /* RF6_TPORT */
3232                         case 160+5:
3233                         {
3234                                 int i, oldfy, oldfx;
3235                                 u32b flgs[TR_FLAG_SIZE];
3236                                 object_type *o_ptr;
3237
3238                                 oldfy = m_ptr->fy;
3239                                 oldfx = m_ptr->fx;
3240
3241                                 if (see_m)
3242                                 {
3243 #ifdef JP
3244 msg_format("%^s¤¬¥Æ¥ì¥Ý¡¼¥È¤·¤¿¡£", m_name);
3245 #else
3246                                         msg_format("%^s teleports away.", m_name);
3247 #endif
3248
3249                                 }
3250
3251                                 teleport_away(m_idx, MAX_SIGHT * 2 + 5, FALSE);
3252
3253                                 if (los(py, px, oldfy, oldfx) && !world_monster && see_m)
3254                                 {
3255                                         for (i=INVEN_RARM;i<INVEN_TOTAL;i++)
3256                                         {
3257                                                 o_ptr = &inventory[i];
3258                                                 if(!cursed_p(o_ptr))
3259                                                 {
3260                                                         object_flags(o_ptr, flgs);
3261
3262                                                         if((have_flag(flgs, TR_TELEPORT)) || (p_ptr->muta1 & MUT1_VTELEPORT) || (p_ptr->pclass == CLASS_IMITATOR))
3263                                                         {
3264 #ifdef JP
3265                                                                 if(get_check_strict("¤Ä¤¤¤Æ¤¤¤¤Þ¤¹¤«¡©", CHECK_OKAY_CANCEL))
3266 #else
3267                                                                 if(get_check_strict("Do you follow it? ", CHECK_OKAY_CANCEL))
3268 #endif
3269                                                                 {
3270                                                                         if (one_in_(3))
3271                                                                         {
3272                                                                                 teleport_player(200);
3273 #ifdef JP
3274                                                                                 msg_print("¼ºÇÔ¡ª");
3275 #else
3276                                                                                 msg_print("Failed!");
3277 #endif
3278                                                                         }
3279                                                                         else teleport_player_to(m_ptr->fy, m_ptr->fx, TRUE);
3280                                                                         p_ptr->energy_need = ENERGY_NEED();
3281                                                                 }
3282                                                                 break;
3283                                                         }
3284                                                 }
3285                                         }
3286                                 }
3287                                 break;
3288                         }
3289
3290                         /* RF6_WORLD */
3291                         case 160+6:
3292                         {
3293 #if 0
3294                                 int who = 0;
3295                                 if(m_ptr->r_idx = MON_DIO) who == 1;
3296                                 else if(m_ptr->r_idx = MON_WONG) who == 3;
3297                                 dam = who;
3298                                 if(!process_the_world(randint1(2)+2, who, los(py, px, m_ptr->fy, m_ptr->fx))) return (FALSE);
3299 #endif
3300                                 return FALSE;
3301                         }
3302
3303                         /* RF6_SPECIAL */
3304                         case 160+7:
3305                         {
3306                                 int k;
3307                                 if (p_ptr->inside_arena || p_ptr->inside_battle) return FALSE;
3308                                 switch(m_ptr->r_idx)
3309                                 {
3310                                         case MON_OHMU:
3311                                         {
3312                                                 for (k = 0; k < 6; k++)
3313                                                 {
3314                                                         summon_specific(m_idx, m_ptr->fy, m_ptr->fx, rlev, SUMMON_BIZARRE1, PM_ALLOW_GROUP);
3315                                                 }
3316                                                 return FALSE;
3317                                         }
3318                                 default:
3319                                         if (r_ptr->d_char == 'B')
3320                                         {
3321                                                 if (one_in_(3))
3322                                                 {
3323                                                         if (see_m)
3324                                                         {
3325 #ifdef JP
3326                                                                 msg_format("%^s¤ÏÆÍÁ³µÞ¾å¾º¤·¤Æ»ë³¦¤«¤é¾Ã¤¨¤¿!", m_name);
3327 #else
3328                                                                 msg_format("%^s suddenly go out of your sight!", m_name);
3329 #endif
3330                                                         }
3331                                                         teleport_away(m_idx, 10, FALSE);
3332                                                         p_ptr->update |= (PU_MONSTERS | PU_MON_LITE);
3333                                                         break;
3334                                                 }
3335                                                 else
3336                                                 {
3337                                                         /* Not implemented */
3338                                                         return FALSE;
3339                                                 }
3340                                                 break;
3341                                         }
3342
3343                                         /* Something is wrong */
3344                                         else return FALSE;
3345                                 }
3346
3347                                 /* done */
3348                                 break;
3349                         }
3350                         /* RF6_TELE_TO */
3351                         case 160+8:
3352                         {
3353                                 /* Not implemented */
3354                                 return FALSE;
3355                         }
3356
3357                         /* RF6_TELE_AWAY */
3358                         case 160+9:
3359                         {
3360                                 bool resists_tele = FALSE;
3361
3362                                 if (known)
3363                                 {
3364                                         if (see_either)
3365                                         {
3366 #ifdef JP
3367 msg_format("%^s¤Ï%s¤ò¥Æ¥ì¥Ý¡¼¥È¤µ¤»¤¿¡£", m_name, t_name);
3368 #else
3369                                                 msg_format("%^s teleports %s away.", m_name, t_name);
3370 #endif
3371
3372                                         }
3373                                         else
3374                                         {
3375                                                 mon_fight = TRUE;
3376                                         }
3377                                 }
3378
3379                                 if (tr_ptr->flags3 & RF3_RES_TELE)
3380                                 {
3381                                         if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flags3 & (RF3_RES_ALL)))
3382                                         {
3383                                                 if (see_t)
3384                                                 {
3385                                                         tr_ptr->r_flags3 |= RF3_RES_TELE;
3386 #ifdef JP
3387 msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
3388 #else
3389                                                         msg_format("%^s is unaffected!", t_name);
3390 #endif
3391
3392                                                 }
3393
3394                                                 resists_tele = TRUE;
3395                                         }
3396                                         else if (tr_ptr->level > randint1(100))
3397                                         {
3398                                                 if (see_t)
3399                                                 {
3400                                                         tr_ptr->r_flags3 |= RF3_RES_TELE;
3401 #ifdef JP
3402 msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
3403 #else
3404                                                         msg_format("%^s resists!", t_name);
3405 #endif
3406
3407                                                 }
3408
3409                                                 resists_tele = TRUE;
3410                                         }
3411                                 }
3412
3413                                 if (!resists_tele)
3414                                 {
3415                                         if (t_idx == p_ptr->riding) teleport_player(MAX_SIGHT * 2 + 5);
3416                                         else teleport_away(t_idx, MAX_SIGHT * 2 + 5, FALSE);
3417                                 }
3418
3419                                 break;
3420                         }
3421
3422                         /* RF6_TELE_LEVEL */
3423                         case 160+10:
3424                         {
3425                                 /* Not implemented */
3426                                 return FALSE;
3427                         }
3428
3429                         /* RF6_PSY_SPEAR */
3430                         case 160+11:
3431                         {
3432                                 if (known)
3433                                 {
3434                                         if (see_either)
3435                                         {
3436 #ifdef JP
3437 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¸÷¤Î·õ¤òÊü¤Ã¤¿¡£", m_name, t_name);
3438 #else
3439                                                 msg_format("%^s throw a Psycho-spear at %s.", m_name, t_name);
3440 #endif
3441
3442                                         }
3443                                         else
3444                                         {
3445                                                 mon_fight = TRUE;
3446                                         }
3447                                 }
3448
3449                                 dam = (r_ptr->flags2 & RF2_POWERFUL) ? (randint1(rlev * 2) + 180) : (randint1(rlev * 3 / 2) + 120);
3450                                 monst_beam_monst(m_idx, y, x, GF_PSY_SPEAR,
3451                                         dam, MS_PSY_SPEAR, learnable);
3452                                 break;
3453                         }
3454
3455                         /* RF6_DARKNESS */
3456                         case 160+12:
3457                         {
3458                                 if (known)
3459                                 {
3460                                         if (see_m)
3461                                         {
3462 #ifdef JP
3463 msg_format("%^s¤¬°Å°Ç¤ÎÃæ¤Ç¼ê¤ò¿¶¤Ã¤¿¡£", m_name);
3464 #else
3465                                                 msg_format("%^s gestures in shadow.", m_name);
3466 #endif
3467
3468
3469                                                 if (see_t)
3470                                                 {
3471 #ifdef JP
3472 msg_format("%^s¤Ï°Å°Ç¤ËÊñ¤Þ¤ì¤¿¡£", t_name);
3473 #else
3474                                                         msg_format("%^s is surrounded by darkness.", t_name);
3475 #endif
3476
3477                                                 }
3478                                         }
3479                                         else
3480                                         {
3481                                                 mon_fight = TRUE;
3482                                         }
3483                                 }
3484
3485                                 (void)project(m_idx, 3, y, x, 0, GF_DARK_WEAK, PROJECT_GRID | PROJECT_KILL | PROJECT_MONSTER, MS_DARKNESS);
3486
3487                                 unlite_room(y, x);
3488
3489                                 break;
3490                         }
3491
3492                         /* RF6_TRAPS */
3493                         case 160+13:
3494                         {
3495 #if 0
3496                                 if (known)
3497                                 {
3498                                         if (see_m)
3499                                         {
3500 #ifdef JP
3501 msg_format("%^s¤¬¼öÊ¸¤ò¾§¤¨¤Æ¼Ù°¤ËÈù¾Ð¤ó¤À¡£", m_name);
3502 #else
3503                                                 msg_format("%^s casts a spell and cackles evilly.", m_name);
3504 #endif
3505                                         }
3506                                         else
3507                                         {
3508 #ifdef JP
3509 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3510 #else
3511                                                 msg_format("%^s mumbles.", m_name);
3512 #endif
3513                                         }
3514                                 }
3515
3516                                 trap_creation(y, x);
3517 #endif
3518                                 break;
3519                         }
3520
3521                         /* RF6_FORGET */
3522                         case 160+14:
3523                         {
3524                                 /* Not implemented */
3525                                 return FALSE;
3526                         }
3527
3528                         /* RF6_RAISE_DEAD */
3529                         case 160+15:
3530                         {
3531                                 if (known)
3532                                 {
3533                                         if (see_either)
3534                                         {
3535                                                 disturb(1, 0);
3536 #ifdef JP
3537                                                 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3538 #else
3539                                                 if (blind) msg_format("%^s mumbles.", m_name);
3540 #endif
3541
3542 #ifdef JP
3543                                                 else msg_format("%^s¤¬»à¼ÔÉü³è¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3544 #else
3545                                                 else msg_format("%^s casts a spell to revive corpses.", m_name);
3546 #endif
3547                                         }
3548                                         else
3549                                         {
3550                                                 mon_fight = TRUE;
3551                                         }
3552                                 }
3553                                 animate_dead(m_idx, m_ptr->fy, m_ptr->fx);
3554                                 break;
3555                         }
3556
3557                         /* RF6_SUMMON_KIN */
3558                         case 160+16:
3559                         {
3560                                 if (known)
3561                                 {
3562                                         if (see_either)
3563                                         {
3564                                                 disturb(1, 0);
3565
3566                                                 if (m_ptr->r_idx == MON_ROLENTO)
3567                                                 {
3568 #ifdef JP
3569                                                         msg_format("%^s¤Ï¼êÜØÃÆ¤ò¤Ð¤é¤Þ¤¤¤¿¡£",
3570                                                                 m_name);
3571 #else
3572                                                         msg_format("%^s throws some hand grenades.",
3573                                                                 m_name);
3574 #endif
3575                                                 }
3576                                                 else if (m_ptr->r_idx == MON_SERPENT || m_ptr->r_idx == MON_ZOMBI_SERPENT)
3577                                                 {
3578 #ifdef JP
3579                                                         msg_format("%^s¤¬¥À¥ó¥¸¥ç¥ó¤Î¼ç¤ò¾¤´¤·¤¿¡£", m_name);
3580 #else
3581                                                         msg_format("%^s magically summons guardians of dungeons.", m_name);
3582 #endif
3583                                                 }
3584                                                 else
3585                                                 {
3586 #ifdef JP
3587 msg_format("%s¤¬ËâË¡¤Ç%s¤ò¾¤´¤·¤¿¡£", m_name,
3588   ((r_ptr->flags1 & RF1_UNIQUE) ? "¼ê²¼" : "Ãç´Ö"));
3589 #else
3590                                                         msg_format("%^s magically summons %s %s.", m_name, m_poss,
3591                                                                           ((r_ptr->flags1 & RF1_UNIQUE) ? "minions" : "kin"));
3592 #endif
3593                                                 }
3594
3595                                         }
3596                                         else
3597                                         {
3598                                                 mon_fight = TRUE;
3599                                         }
3600                                 }
3601
3602                                 if(m_ptr->r_idx == MON_ROLENTO)
3603                                 {
3604                                         int num = 1 + randint1(3);
3605                                         for (k = 0; k < num; k++)
3606                                         {
3607                                                 count += summon_named_creature(m_idx, y, x, MON_SHURYUUDAN, p_mode);
3608                                         }
3609                                 }
3610                                 else if(m_ptr->r_idx == MON_THORONDOR ||
3611                                         m_ptr->r_idx == MON_GWAIHIR ||
3612                                         m_ptr->r_idx == MON_MENELDOR)
3613                                 {
3614                                         int num = 4 + randint1(3);
3615                                         for (k = 0; k < num; k++)
3616                                         {
3617                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_EAGLES, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | p_mode));
3618                                         }
3619                                 }
3620                                 else if(m_ptr->r_idx == MON_LOUSY)
3621                                 {
3622                                         int num = 2 + randint1(3);
3623                                         for (k = 0; k < num; k++)
3624                                         {
3625                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_LOUSE, (PM_ALLOW_GROUP | p_mode));
3626                                         }
3627                                 }
3628                                 else if(m_ptr->r_idx == MON_BULLGATES)
3629                                 {
3630                                         int num = 2 + randint1(3);
3631                                         for (k = 0; k < num; k++)
3632                                         {
3633                                                 count += summon_named_creature(m_idx, y, x, 921, p_mode);
3634                                         }
3635                                 }
3636                                 else if (m_ptr->r_idx == MON_CALDARM)
3637                                 {
3638                                         int num = randint1(3);
3639                                         for (k = 0; k < num; k++)
3640                                         {
3641                                                 count += summon_named_creature(m_idx, y, x, 930, p_mode);
3642                                         }
3643                                 }
3644                                 else if (m_ptr->r_idx == MON_SERPENT || m_ptr->r_idx == MON_ZOMBI_SERPENT)
3645                                 {
3646                                         int num = 2 + randint1(3);
3647                                         for (k = 0; k < num; k++)
3648                                         {
3649                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_GUARDIANS, (PM_ALLOW_GROUP | p_mode | PM_ALLOW_UNIQUE));
3650                                         }
3651                                 }
3652                                 else
3653                                 {
3654                                         summon_kin_type = r_ptr->d_char;
3655
3656                                         for (k = 0; k < 4; k++)
3657                                         {
3658                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_KIN, (PM_ALLOW_GROUP | p_mode));
3659                                         }
3660                                 }
3661
3662                                 if (known && !see_t && count)
3663                                 {
3664                                      mon_fight = TRUE;
3665                                 }
3666
3667                                 break;
3668                         }
3669
3670                         /* RF6_S_CYBER */
3671                         case 160+17:
3672                         {
3673                                 if (known)
3674                                 {
3675                                         if (see_either)
3676                                         {
3677                                                 disturb(1, 0);
3678
3679 #ifdef JP
3680 msg_format("%^s¤¬¥µ¥¤¥Ð¡¼¥Ç¡¼¥â¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
3681 #else
3682                                                 msg_format("%^s magically summons Cyberdemons!", m_name);
3683 #endif
3684
3685                                         }
3686                                         else
3687                                         {
3688                                                 mon_fight = TRUE;
3689                                         }
3690                                 }
3691
3692                                 if (is_friendly(m_ptr))
3693                                 {
3694                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_CYBER, (PM_ALLOW_GROUP | p_mode));
3695                                 }
3696                                 else
3697                                 {
3698                                         count += summon_cyber(m_idx, y, x);
3699                                 }
3700
3701                                 if (known && !see_t && count)
3702                                 {
3703                                      mon_fight = TRUE;
3704                                 }
3705
3706                                 break;
3707                         }
3708
3709                         /* RF6_S_MONSTER */
3710                         case 160+18:
3711                         {
3712                                 if (known)
3713                                 {
3714                                         if (see_either)
3715                                         {
3716                                                 disturb(1, 0);
3717
3718 #ifdef JP
3719 msg_format("%^s¤¬ËâË¡¤ÇÃç´Ö¤ò¾¤´¤·¤¿¡ª", m_name);
3720 #else
3721                                                 msg_format("%^s magically summons help!", m_name);
3722 #endif
3723
3724                                         }
3725                                         else
3726                                         {
3727                                                 mon_fight = TRUE;
3728                                         }
3729                                 }
3730
3731                                 count += summon_specific(m_idx, y, x, rlev, 0, (p_mode | u_mode));
3732
3733                                 if (known && !see_t && count)
3734                                 {
3735                                       mon_fight = TRUE;
3736                                 }
3737
3738                                 break;
3739                         }
3740
3741                         /* RF6_S_MONSTERS */
3742                         case 160+19:
3743                         {
3744                                 if (known)
3745                                 {
3746                                         if (see_either)
3747                                         {
3748                                                 disturb(1, 0);
3749
3750 #ifdef JP
3751 msg_format("%^s¤¬ËâË¡¤Ç¥â¥ó¥¹¥¿¡¼¤ò¾¤´¤·¤¿¡ª", m_name);
3752 #else
3753                                                 msg_format("%^s magically summons monsters!", m_name);
3754 #endif
3755
3756                                         }
3757                                         else
3758                                         {
3759                                                 mon_fight = TRUE;
3760                                         }
3761                                 }
3762
3763                                 for (k = 0; k < s_num_6; k++)
3764                                 {
3765                                         count += summon_specific(m_idx, y, x, rlev, 0, (PM_ALLOW_GROUP | p_mode | u_mode));
3766                                 }
3767
3768                                 if (known && !see_t && count)
3769                                 {
3770                                   mon_fight = TRUE;
3771                                 }
3772
3773                                 break;
3774                         }
3775
3776                         /* RF6_S_ANT */
3777                         case 160+20:
3778                         {
3779                                 if (known)
3780                                 {
3781                                         if (see_either)
3782                                         {
3783                                                 disturb(1, 0);
3784
3785 #ifdef JP
3786 msg_format("%^s¤¬ËâË¡¤Ç¥¢¥ê¤ò¾¤´¤·¤¿¡£", m_name);
3787 #else
3788                                                 msg_format("%^s magically summons ants.", m_name);
3789 #endif
3790
3791                                         }
3792                                         else
3793                                         {
3794                                                 mon_fight = TRUE;
3795                                         }
3796                                 }
3797
3798                                 for (k = 0; k < s_num_6; k++)
3799                                 {
3800                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_ANT, (PM_ALLOW_GROUP | p_mode));
3801                                 }
3802
3803                                 if (known && !see_t && count)
3804                                 {
3805                                      mon_fight = TRUE;
3806                                 }
3807
3808                                 break;
3809                         }
3810
3811                         /* RF6_S_SPIDER */
3812                         case 160+21:
3813                         {
3814                                 if (known)
3815                                 {
3816                                         if (see_either)
3817                                         {
3818                                                 disturb(1, 0);
3819
3820 #ifdef JP
3821 msg_format("%^s¤¬ËâË¡¤Ç¥¯¥â¤ò¾¤´¤·¤¿¡£", m_name);
3822 #else
3823                                                 msg_format("%^s magically summons spiders.", m_name);
3824 #endif
3825
3826                                         }
3827                                         else
3828                                         {
3829                                                 mon_fight = TRUE;
3830                                         }
3831                                 }
3832
3833                                 for (k = 0; k < s_num_6; k++)
3834                                 {
3835                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_SPIDER, (PM_ALLOW_GROUP | p_mode));
3836                                 }
3837
3838                                 if (known && !see_t && count)
3839                                 {
3840                                     mon_fight = TRUE;
3841                                 }
3842
3843                                 break;
3844                         }
3845
3846                         /* RF6_S_HOUND */
3847                         case 160+22:
3848                         {
3849                                 if (known)
3850                                 {
3851                                         if (see_either)
3852                                         {
3853                                                 disturb(1, 0);
3854
3855 #ifdef JP
3856 msg_format("%^s¤¬ËâË¡¤Ç¥Ï¥¦¥ó¥É¤ò¾¤´¤·¤¿¡£", m_name);
3857 #else
3858                                                 msg_format("%^s magically summons hounds.", m_name);
3859 #endif
3860
3861                                         }
3862                                         else
3863                                         {
3864                                                 mon_fight = TRUE;
3865                                         }
3866                                 }
3867
3868                                 for (k = 0; k < s_num_4; k++)
3869                                 {
3870                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HOUND, (PM_ALLOW_GROUP | p_mode));
3871                                 }
3872
3873                                 if (known && !see_t && count)
3874                                 {
3875                                      mon_fight = TRUE;
3876                                 }
3877
3878                                 break;
3879                         }
3880
3881                         /* RF6_S_HYDRA */
3882                         case 160+23:
3883                         {
3884                                 if (known)
3885                                 {
3886                                         if (see_either)
3887                                         {
3888                                                 disturb(1, 0);
3889
3890 #ifdef JP
3891 msg_format("%^s¤¬ËâË¡¤Ç¥Ò¥É¥é¤ò¾¤´¤·¤¿¡£", m_name);
3892 #else
3893                                                 msg_format("%^s magically summons hydras.", m_name);
3894 #endif
3895
3896                                         }
3897                                         else
3898                                         {
3899                                                 mon_fight = TRUE;
3900                                         }
3901                                 }
3902
3903                                 for (k = 0; k < s_num_4; k++)
3904                                 {
3905                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HYDRA, (PM_ALLOW_GROUP | p_mode));
3906                                 }
3907
3908                                 if (known && !see_t && count)
3909                                 {
3910                                     mon_fight = TRUE;
3911                                 }
3912
3913                                 break;
3914                         }
3915
3916                         /* RF6_S_ANGEL */
3917                         case 160+24:
3918                         {
3919                                 int num = 1;
3920                                 if (known)
3921                                 {
3922                                         if (see_either)
3923                                         {
3924                                                 disturb(1, 0);
3925
3926 #ifdef JP
3927 msg_format("%^s¤¬ËâË¡¤ÇÅ·»È¤ò¾¤´¤·¤¿¡ª", m_name);
3928 #else
3929                                                 msg_format("%^s magically summons an angel!", m_name);
3930 #endif
3931
3932                                         }
3933                                         else
3934                                         {
3935                                                 mon_fight = TRUE;
3936                                         }
3937                                 }
3938
3939                                 if ((r_ptr->flags1 & RF1_UNIQUE) && !easy_band)
3940                                 {
3941                                         num += r_ptr->level/40;
3942                                 }
3943
3944                                 for (k = 0; k < num; k++)
3945                                 {
3946                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_ANGEL, (PM_ALLOW_GROUP | p_mode));
3947                                 }
3948
3949                                 if (known && !see_t && count)
3950                                 {
3951                                    mon_fight = TRUE;
3952                                 }
3953
3954                                 break;
3955                         }
3956
3957                         /* RF6_S_DEMON */
3958                         case 160+25:
3959                         {
3960                                 if (known)
3961                                 {
3962                                         if (see_either)
3963                                         {
3964                                                 disturb(1, 0);
3965
3966 #ifdef JP
3967 msg_format("%^s¤¬ËâË¡¤Çº®ÆÙ¤ÎµÜÄî¤«¤é¥Ç¡¼¥â¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
3968 #else
3969                                                 msg_format("%^s magically summons a demon from the Courts of Chaos!", m_name);
3970 #endif
3971
3972                                         }
3973                                         else
3974                                         {
3975                                                 mon_fight = TRUE;
3976                                         }
3977                                 }
3978
3979                                 for (k = 0; k < 1; k++)
3980                                 {
3981                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_DEMON, (PM_ALLOW_GROUP | p_mode));
3982                                 }
3983
3984                                 if (known && !see_t && count)
3985                                 {
3986                                     mon_fight = TRUE;
3987                                 }
3988
3989                                 break;
3990                         }
3991
3992                         /* RF6_S_UNDEAD */
3993                         case 160+26:
3994                         {
3995                                 if (known)
3996                                 {
3997                                         if (see_either)
3998                                         {
3999                                                 disturb(1, 0);
4000
4001 #ifdef JP
4002 msg_format("%s¤¬ËâË¡¤Ç¥¢¥ó¥Ç¥Ã¥É¤ò¾¤´¤·¤¿¡£", m_name);
4003 #else
4004                                                 msg_format("%^s magically summons undead.", m_name);
4005 #endif
4006
4007                                         }
4008                                         else
4009                                         {
4010                                                 mon_fight = TRUE;
4011                                         }
4012                                 }
4013
4014                                 for (k = 0; k < 1; k++)
4015                                 {
4016                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_UNDEAD, (PM_ALLOW_GROUP | p_mode));
4017                                 }
4018
4019                                 if (known && !see_t && count)
4020                                 {
4021                                     mon_fight = TRUE;
4022                                 }
4023
4024                                 break;
4025                         }
4026
4027                         /* RF6_S_DRAGON */
4028                         case 160+27:
4029                         {
4030                                 if (known)
4031                                 {
4032                                         if (see_either)
4033                                         {
4034                                                 disturb(1, 0);
4035
4036 #ifdef JP
4037 msg_format("%^s¤¬ËâË¡¤Ç¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
4038 #else
4039                                                 msg_format("%^s magically summons a dragon!", m_name);
4040 #endif
4041
4042                                         }
4043                                         else
4044                                         {
4045                                                 mon_fight = TRUE;
4046                                         }
4047                                 }
4048
4049                                 for (k = 0; k < 1; k++)
4050                                 {
4051                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_DRAGON, (PM_ALLOW_GROUP | p_mode));
4052                                 }
4053
4054                                 if (known && !see_t && count)
4055                                 {
4056                                     mon_fight = TRUE;
4057                                 }
4058
4059                                 break;
4060                         }
4061
4062                         /* RF6_S_HI_UNDEAD */
4063                         case 160+28:
4064                         {
4065                                 if (known)
4066                                 {
4067                                         if (see_either)
4068                                         {
4069                                                 disturb(1, 0);
4070
4071 #ifdef JP
4072 msg_format("%s¤¬ËâË¡¤Ç¥¢¥ó¥Ç¥Ã¥É¤ò¾¤´¤·¤¿¡£", m_name);
4073 #else
4074                                                 msg_format("%^s magically summons undead.", m_name);
4075 #endif
4076
4077                                         }
4078                                         else
4079                                         {
4080                                                 mon_fight = TRUE;
4081                                         }
4082                                 }
4083
4084                                 for (k = 0; k < s_num_6; k++)
4085                                 {
4086                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_UNDEAD, (PM_ALLOW_GROUP | p_mode | u_mode));
4087                                 }
4088
4089                                 if (known && !see_t && count)
4090                                 {
4091                                    mon_fight = TRUE;
4092                                 }
4093
4094                                 break;
4095                         }
4096
4097                         /* RF6_S_HI_DRAGON */
4098                         case 160+29:
4099                         {
4100                                 if (known)
4101                                 {
4102                                         if (see_either)
4103                                         {
4104                                                 disturb(1, 0);
4105
4106 #ifdef JP
4107 msg_format("%^s¤¬ËâË¡¤Ç¸ÅÂå¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
4108 #else
4109                                                 msg_format("%^s magically summons ancient dragons!", m_name);
4110 #endif
4111
4112                                         }
4113                                         else
4114                                         {
4115                                                 mon_fight = TRUE;
4116                                         }
4117                                 }
4118
4119                                 for (k = 0; k < s_num_4; k++)
4120                                 {
4121                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_DRAGON, (PM_ALLOW_GROUP | p_mode | u_mode));
4122                                 }
4123
4124                                 if (known && !see_t && count)
4125                                 {
4126                                    mon_fight = TRUE;
4127                                 }
4128
4129                                 break;
4130                         }
4131
4132                         /* RF6_S_AMBERITES */
4133                         case 160+30:
4134                         {
4135                                 if (known)
4136                                 {
4137                                         if (see_either)
4138                                         {
4139                                                 disturb(1, 0);
4140
4141 #ifdef JP
4142 msg_format("%^s¤¬¥¢¥ó¥Ð¡¼¤Î²¦Â²¤ò¾¤´¤·¤¿¡ª", m_name);
4143 #else
4144                                                 msg_format("%^s magically summons Lords of Amber!", m_name);
4145 #endif
4146
4147                                         }
4148                                         else
4149                                         {
4150                                                 mon_fight = TRUE;
4151                                         }
4152                                 }
4153
4154                                 for (k = 0; k < s_num_4; k++)
4155                                 {
4156                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_AMBERITES, (PM_ALLOW_GROUP | p_mode | PM_ALLOW_UNIQUE));
4157                                 }
4158
4159                                 if (known && !see_t && count)
4160                                 {
4161                                    mon_fight = TRUE;
4162                                 }
4163
4164                                 break;
4165                         }
4166
4167                         /* RF6_S_UNIQUE */
4168                         case 160+31:
4169                         {
4170                                 if (known)
4171                                 {
4172                                         if (see_either)
4173                                         {
4174                                                 disturb(1, 0);
4175
4176 #ifdef JP
4177 msg_format("%^s¤¬ËâË¡¤ÇÆÃÊÌ¤Ê¶¯Å¨¤ò¾¤´¤·¤¿¡ª", m_name);
4178 #else
4179                                                 msg_format("%^s magically summons special opponents!", m_name);
4180 #endif
4181
4182                                         }
4183                                         else
4184                                         {
4185                                                 mon_fight = TRUE;
4186                                         }
4187                                 }
4188
4189                                 for (k = 0; k < s_num_4; k++)
4190                                 {
4191                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_UNIQUE, (PM_ALLOW_GROUP | p_mode | PM_ALLOW_UNIQUE));
4192                                 }
4193
4194                                 if (known && !see_t && count)
4195                                 {
4196                                    mon_fight = TRUE;
4197                                 }
4198
4199                                 break;
4200                         }
4201                 }
4202
4203                 if (wake_up)
4204                 {
4205                         t_ptr->csleep = 0;
4206                 }
4207
4208                 if (fear && see_t)
4209                 {
4210 #ifdef JP
4211 msg_format("%^s¤Ï¶²ÉÝ¤·¤ÆÆ¨¤²½Ð¤·¤¿¡ª", t_name);
4212 #else
4213                         msg_format("%^s flees in terror!", t_name);
4214 #endif
4215
4216                 }
4217
4218                 if (see_m && maneable && !world_monster && !p_ptr->blind && (p_ptr->pclass == CLASS_IMITATOR))
4219                 {
4220                         if (thrown_spell != 167)
4221                         {
4222                                 if (p_ptr->mane_num == MAX_MANE)
4223                                 {
4224                                         int i;
4225                                         p_ptr->mane_num--;
4226                                         for (i = 0;i < p_ptr->mane_num-1;i++)
4227                                         {
4228                                                 p_ptr->mane_spell[i] = p_ptr->mane_spell[i+1];
4229                                                 p_ptr->mane_dam[i] = p_ptr->mane_dam[i+1];
4230                                         }
4231                                 }
4232                                 p_ptr->mane_spell[p_ptr->mane_num] = thrown_spell - 96;
4233                                 p_ptr->mane_dam[p_ptr->mane_num] = dam;
4234                                 p_ptr->mane_num++;
4235                                 new_mane = TRUE;
4236
4237                                 p_ptr->redraw |= (PR_MANE);
4238                         }
4239                 }
4240
4241                 /* Remember what the monster did, if we saw it */
4242                 if (see_m)
4243                 {
4244                         /* Inate spell */
4245                         if (thrown_spell < 32*4)
4246                         {
4247                                 r_ptr->r_flags4 |= (1L << (thrown_spell - 32*3));
4248                                 if (r_ptr->r_cast_inate < MAX_UCHAR) r_ptr->r_cast_inate++;
4249                         }
4250
4251                         /* Bolt or Ball */
4252                         else if (thrown_spell < 32*5)
4253                         {
4254                                 r_ptr->r_flags5 |= (1L << (thrown_spell - 32*4));
4255                                 if (r_ptr->r_cast_spell < MAX_UCHAR) r_ptr->r_cast_spell++;
4256                         }
4257
4258                         /* Special spell */
4259                         else if (thrown_spell < 32*6)
4260                         {
4261                                 r_ptr->r_flags6 |= (1L << (thrown_spell - 32*5));
4262                                 if (r_ptr->r_cast_spell < MAX_UCHAR) r_ptr->r_cast_spell++;
4263                         }
4264                 }
4265
4266                 /* Always take note of monsters that kill you */
4267                 if (p_ptr->is_dead && (r_ptr->r_deaths < MAX_SHORT) && !p_ptr->inside_arena)
4268                 {
4269                         r_ptr->r_deaths++;
4270                 }
4271
4272                 /* A spell was cast */
4273                 return (TRUE);
4274         }
4275
4276         /* No enemy found */
4277         return (FALSE);
4278 }