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