src/mspells2.c

   1 /* File: mspells2.c */
   2
   3 /* Purpose: Monster spells (attack monster) */
   4
   5 /*
   6  * Copyright (c) 1989 James E. Wilson, Robert A. Koeneke
   7  *
   8  * This software may be copied and distributed for educational, research, and
   9  * not for profit purposes provided that this copyright and statement are
  10  * included in all such copies.
  11  */
  12
  13 #include "angband.h"
  14
  15
  16 /*
  17  * Monster casts a breath (or ball) attack at another monster.
  18  * Pass over any monsters that may be in the way
  19  * Affect grids, objects, monsters, and the player
  20  */
  21 static void monst_breath_monst(int m_idx, int y, int x, int typ, int dam_hp, int rad, bool breath, int monspell, bool learnable)
  22 {
  23         int flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_MONSTER;
  24
  25         monster_type *m_ptr = &m_list[m_idx];
  26         monster_race *r_ptr = &r_info[m_ptr->r_idx];
  27
  28         /* Determine the radius of the blast */
  29         if (rad < 1 && breath) rad = (r_ptr->flags2 & RF2_POWERFUL) ? 3 : 2;
  30
  31         /* Handle breath attacks */
  32         if (breath) rad = 0 - rad;
  33
  34         if (typ == GF_ROCKET) flg |= PROJECT_STOP;
  35
  36         (void)project(m_idx, rad, y, x, dam_hp, typ, flg, (learnable ? monspell : -1));
  37 }
  38
  39
  40 /*
  41  * Monster casts a bolt at another monster
  42  * Stop if we hit a monster
  43  * Affect monsters and the player
  44  */
  45 static void monst_bolt_monst(int m_idx, int y, int x, int typ, int dam_hp, int monspell, bool learnable)
  46 {
  47         int flg = PROJECT_STOP | PROJECT_KILL | PROJECT_MONSTER | PROJECT_REFLECTABLE;
  48
  49         (void)project(m_idx, 0, y, x, dam_hp, typ, flg, (learnable ? monspell : -1));
  50 }
  51
  52 static void monst_beam_monst(int m_idx, int y, int x, int typ, int dam_hp, int monspell, bool learnable)
  53 {
  54         int flg = PROJECT_BEAM | PROJECT_KILL | PROJECT_THRU | PROJECT_MONSTER;
  55
  56         (void)project(m_idx, 0, y, x, dam_hp, typ, flg, (learnable ? monspell : -1));
  57 }
  58
  59 /*
  60  * Determine if a beam spell will hit the target.
  61  */
  62 static bool direct_beam(int y1, int x1, int y2, int x2, monster_type *m_ptr)
  63 {
  64         bool hit2 = FALSE;
  65         int i, y, x;
  66
  67         int grid_n = 0;
  68         u16b grid_g[512];
  69
  70         bool friend = is_pet(m_ptr);
  71
  72         /* Check the projection path */
  73         grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, PROJECT_THRU);
  74
  75         /* No grid is ever projectable from itself */
  76         if (!grid_n) return (FALSE);
  77
  78         for (i = 0; i < grid_n; i++)
  79         {
  80                 y = GRID_Y(grid_g[i]);
  81                 x = GRID_X(grid_g[i]);
  82
  83                 if (y == y2 && x == x2)
  84                         hit2 = TRUE;
  85                 else if (friend && cave[y][x].m_idx > 0 &&
  86                          !are_enemies(m_ptr, &m_list[cave[y][x].m_idx]))
  87                 {
  88                         /* Friends don't shoot friends */
  89                         return FALSE;
  90                 }
  91
  92                 if (friend && y == py && x == px)
  93                         return FALSE;
  94         }
  95         if (!hit2)
  96                 return FALSE;
  97         return TRUE;
  98 }
  99
 100 static bool breath_direct(int y1, int x1, int y2, int x2, int rad, bool disint_ball, bool friend)
 101 {
 102         /* Must be the same as projectable() */
 103
 104         int i, y, x;
 105
 106         int grid_n = 0;
 107         u16b grid_g[512];
 108
 109         int grids = 0;
 110         byte gx[1024], gy[1024];
 111         byte gm[32];
 112         int gm_rad = rad;
 113
 114         bool hit2 = FALSE;
 115         bool hityou = FALSE;
 116
 117         /* Check the projection path */
 118         grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, disint_ball ? PROJECT_DISI : 0);
 119         breath_shape(grid_g, grid_n, &grids, gx, gy, gm, &gm_rad, rad, y1, x1, y2, x2, disint_ball, FALSE);
 120
 121         for (i = 0; i < grids; i++)
 122         {
 123                 /* Extract the location */
 124                 y = gy[i];
 125                 x = gx[i];
 126
 127                 if (y == y2 && x == x2)
 128                         hit2 = TRUE;
 129                 if (y == py && x == px)
 130                         hityou = TRUE;
 131         }
 132         if (!hit2)
 133                 return FALSE;
 134         if (friend && hityou)
 135                 return FALSE;
 136         return TRUE;
 137 }
 138
 139 /*
 140  * Monster tries to 'cast a spell' (or breath, etc)
 141  * at another monster.
 142  *
 143  * The player is only disturbed if able to be affected by the spell.
 144  */
 145 bool monst_spell_monst(int m_idx)
 146 {
 147         int y = 0, x = 0;
 148         int i, k, t_idx;
 149         int chance, thrown_spell, count = 0;
 150         int rlev;
 151         int dam = 0;
 152         int start;
 153         int plus = 1;
 154         u32b p_mode = 0L, u_mode = 0L;
 155         int s_num_6 = (easy_band ? 2 : 6);
 156         int s_num_4 = (easy_band ? 1 : 4);
 157
 158         byte spell[96], num = 0;
 159
 160         char m_name[160];
 161         char t_name[160];
 162         char m_poss[160];
 163         char ddesc[160];
 164
 165         monster_type *m_ptr = &m_list[m_idx];
 166         monster_type *t_ptr;
 167
 168         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 169         monster_race *tr_ptr;
 170
 171         u32b f4, f5, f6;
 172
 173         bool wake_up = FALSE;
 174         bool fear = FALSE;
 175
 176         bool blind = (p_ptr->blind ? TRUE : FALSE);
 177
 178         bool see_m = m_ptr->ml;
 179         bool maneable = player_has_los_bold(m_ptr->fy, m_ptr->fx);
 180         bool learnable = (see_m && maneable && !world_monster);
 181         bool see_t;
 182         bool see_either;
 183         bool see_both;
 184         bool known;
 185
 186         bool pet = is_pet(m_ptr);
 187
 188         /* Prepare flags for summoning */
 189         if (pet) p_mode |= PM_FORCE_PET;
 190         if (!pet) u_mode |= PM_ALLOW_UNIQUE;
 191
 192         /* Cannot cast spells when confused */
 193         if (m_ptr->confused) return (FALSE);
 194
 195         /* Hack -- Extract the spell probability */
 196         chance = (r_ptr->freq_inate + r_ptr->freq_spell) / 2;
 197
 198         /* Not allowed to cast spells */
 199         if (!chance) return (FALSE);
 200
 201         if (randint0(100) >= chance) return (FALSE);
 202
 203         if (p_ptr->inside_battle)
 204         {
 205                 start = randint1(m_max-1)+m_max;
 206                 if(randint0(2)) plus = -1;
 207         }
 208         else start = m_max + 1;
 209
 210         /* Scan thru all monsters */
 211         for (i = start; ((i < start + m_max) && (i > start - m_max)); i+=plus)
 212         {
 213                 /* The monster itself isn't a target */
 214                 int dummy = (i % m_max);
 215                 if (!dummy) continue;
 216
 217                 t_idx = dummy;
 218                 t_ptr = &m_list[t_idx];
 219                 tr_ptr = &r_info[t_ptr->r_idx];
 220
 221                 /* Paranoia -- Skip dead monsters */
 222                 if (!t_ptr->r_idx) continue;
 223
 224                 if (pet)
 225                 {
 226                         if (pet_t_m_idx && (dummy != pet_t_m_idx) && !los(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx)) continue;
 227                 }
 228
 229                 /* Monster must be 'an enemy' */
 230                 if (!are_enemies(m_ptr, t_ptr)) continue;
 231
 232                 /* Extract the racial spell flags */
 233                 f4 = r_ptr->flags4;
 234                 f5 = r_ptr->flags5;
 235                 f6 = r_ptr->flags6;
 236
 237                 /* Monster must be projectable */
 238                 if (!projectable(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx))
 239                 {
 240                         bool success = FALSE;
 241                         if (m_ptr->target_y)
 242                         {
 243                                 if ((m_ptr->target_y == t_ptr->fy) && (m_ptr->target_x == t_ptr->fx))
 244                                 {
 245                                         y = m_ptr->target_y;
 246                                         x = m_ptr->target_x;
 247                                         f4 &= (RF4_INDIRECT_MASK);
 248                                         f5 &= (RF5_INDIRECT_MASK);
 249                                         f6 &= (RF6_INDIRECT_MASK);
 250                                         success = TRUE;
 251                                 }
 252                         }
 253                         if (!success) continue;
 254                 }
 255
 256                 reset_target(m_ptr);
 257
 258                 /* OK -- we've got a target */
 259                 y = t_ptr->fy;
 260                 x = t_ptr->fx;
 261
 262                 /* Extract the monster level */
 263                 rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
 264
 265                 if (pet)
 266                 {
 267                         f4 &= ~(RF4_SHRIEK);
 268                         f6 &= ~(RF6_DARKNESS | RF6_TRAPS);
 269                 }
 270
 271                 if (dun_level && (!p_ptr->inside_quest || (p_ptr->inside_quest < MIN_RANDOM_QUEST)) && (d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
 272                 {
 273                         f4 &= (RF4_NOMAGIC_MASK);
 274                         f5 &= (RF5_NOMAGIC_MASK);
 275                         f6 &= (RF6_NOMAGIC_MASK);
 276                 }
 277
 278                 if (p_ptr->inside_arena || p_ptr->inside_battle)
 279                 {
 280                         f4 &= ~(RF4_SUMMON_MASK);
 281                         f5 &= ~(RF5_SUMMON_MASK);
 282                         f6 &= ~(RF6_SUMMON_MASK);
 283                 }
 284                 if (p_ptr->inside_battle && !one_in_(3))
 285                 {
 286                         f6 &= ~(RF6_HEAL);
 287                 }
 288
 289                 if (!(p_ptr->pet_extra_flags & PF_TELEPORT) && pet)
 290                 {
 291                         f6 &= ~((RF6_BLINK | RF6_TPORT | RF6_TELE_AWAY));
 292                 }
 293
 294                 if (m_idx == p_ptr->riding)
 295                 {
 296                         f4 &= ~(RF4_RIDING_MASK);
 297                         f5 &= ~(RF5_RIDING_MASK);
 298                         f6 &= ~(RF6_RIDING_MASK);
 299                 }
 300
 301                 if (!(p_ptr->pet_extra_flags & PF_ATTACK_SPELL) && pet)
 302                 {
 303                         f4 &= ~(RF4_ATTACK_MASK);
 304                         f5 &= ~(RF5_ATTACK_MASK);
 305                         f6 &= ~(RF6_ATTACK_MASK);
 306                 }
 307
 308                 if (!(p_ptr->pet_extra_flags & PF_SUMMON_SPELL) && pet)
 309                 {
 310                         f4 &= ~(RF4_SUMMON_MASK);
 311                         f5 &= ~(RF5_SUMMON_MASK);
 312                         f6 &= ~(RF6_SUMMON_MASK);
 313                 }
 314
 315                 /* Prevent collateral damage */
 316                 if (!(p_ptr->pet_extra_flags & PF_BALL_SPELL) && pet && (m_idx != p_ptr->riding))
 317                 {
 318                         int dist = distance(py, px, y, x);
 319
 320                         /* Expected breath radius */
 321                         int rad = (r_ptr->flags2 & RF2_POWERFUL) ? 3 : 2;
 322
 323                         if (dist <= 2)
 324                         {
 325                                 f4 &= ~(RF4_BALL_MASK);
 326                                 f5 &= ~(RF5_BALL_MASK);
 327                                 f6 &= ~(RF6_BALL_MASK);
 328                         }
 329                         else if(dist <= 4)
 330                         {
 331                                 f4 &= ~(RF4_BIG_BALL_MASK);
 332                                 f5 &= ~(RF5_BIG_BALL_MASK);
 333                                 f6 &= ~(RF6_BIG_BALL_MASK);
 334                         }
 335
 336                         if (((f4 & RF4_BEAM_MASK) ||
 337                              (f5 & RF5_BEAM_MASK) ||
 338                              (f6 & RF6_BEAM_MASK)) &&
 339                             !direct_beam(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx, m_ptr))
 340                         {
 341                                 f4 &= ~(RF4_BEAM_MASK);
 342                                 f5 &= ~(RF5_BEAM_MASK);
 343                                 f6 &= ~(RF6_BEAM_MASK);
 344                         }
 345
 346                         if (((f4 & RF4_BREATH_MASK) ||
 347                           (f5 & RF5_BREATH_MASK) ||
 348                           (f6 & RF6_BREATH_MASK)) &&
 349                          !breath_direct(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx, rad, FALSE, TRUE))
 350                         {
 351                                 f4 &= ~(RF4_BREATH_MASK);
 352                                 f5 &= ~(RF5_BREATH_MASK);
 353                                 f6 &= ~(RF6_BREATH_MASK);
 354                         }
 355                         else if ((f4 & RF4_BR_DISI) &&
 356                                  !breath_direct(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx, rad, TRUE, TRUE))
 357                         {
 358                                 f4 &= ~(RF4_BR_DISI);
 359                         }
 360                 }
 361
 362                 /* Remove some spells if necessary */
 363                 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                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2271                                 }
2272
2273                                 wake_up = TRUE;
2274
2275                                 break;
2276                         }
2277
2278                         /* RF5_CAUSE_2 */
2279                         case 128+13:
2280                         {
2281                                 if (known)
2282                                 {
2283                                         if (see_m)
2284                                         {
2285 #ifdef JP
2286 msg_format("%^s¤Ï%s¤ò»Ø¤µ¤·¤Æ¶²¤í¤·¤²¤Ë¼ö¤¤¤ò¤«¤±¤¿¡£", m_name, t_name);
2287 #else
2288                                                 msg_format("%^s points at %s and curses horribly.", m_name, t_name);
2289 #endif
2290
2291                                         }
2292                                         else
2293                                         {
2294                                                 mon_fight = TRUE;
2295                                         }
2296                                 }
2297
2298                                 dam = damroll(8, 8);
2299                                 if ((randint0(100 + rlev/2) < (tr_ptr->level + 35)) ||
2300                                          (tr_ptr->flags3 & RF3_RES_ALL))
2301                                 {
2302                                         /* Memorize a flag */
2303                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
2304                                         {
2305                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
2306                                         }
2307 #ifdef JP
2308 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
2309 #else
2310                                         if (see_both) msg_format("%^s resists!", t_name);
2311 #endif
2312
2313                                 }
2314                                 else
2315                                 {
2316                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2317
2318                                 }
2319
2320                                 wake_up = TRUE;
2321
2322                                 break;
2323                         }
2324
2325                         /* RF5_CAUSE_3 */
2326                         case 128+14:
2327                         {
2328                                 if (known)
2329                                 {
2330                                         if (see_m)
2331                                         {
2332 #ifdef JP
2333 msg_format("%^s¤Ï%s¤ò»Ø¤µ¤·¡¢¶²¤í¤·¤²¤Ë¼öÊ¸¤ò¾§¤¨¤¿¡ª", m_name, t_name);
2334 #else
2335                                                 msg_format("%^s points at %s, incanting terribly!", m_name, t_name);
2336 #endif
2337
2338                                         }
2339                                         else
2340                                         {
2341                                                 mon_fight = TRUE;
2342                                         }
2343                                 }
2344
2345                                 dam = damroll(10, 15);
2346                                 if ((randint0(100 + rlev/2) < (tr_ptr->level + 35)) ||
2347                                          (tr_ptr->flags3 & RF3_RES_ALL))
2348                                 {
2349                                         /* Memorize a flag */
2350                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
2351                                         {
2352                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
2353                                         }
2354 #ifdef JP
2355 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
2356 #else
2357                                         if (see_both) msg_format("%^s resists!", t_name);
2358 #endif
2359
2360                                 }
2361                                 else
2362                                 {
2363                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2364                                 }
2365
2366                                 wake_up = TRUE;
2367
2368                                 break;
2369                         }
2370
2371                         /* RF5_CAUSE_4 */
2372                         case 128+15:
2373                         {
2374                                 if (known)
2375                                 {
2376                                         if (see_m)
2377                                         {
2378 #ifdef JP
2379 msg_format("%^s¤¬%s¤ÎÈë¹¦¤òÆÍ¤¤¤Æ¡¢¡Ö¤ªÁ°¤Ï´û¤Ë»à¤ó¤Ç¤¤¤ë¡×¤È¶«¤ó¤À¡£", m_name, t_name);
2380 #else
2381                                                 msg_format("%^s points at %s, screaming the word, 'DIE!'", m_name, t_name);
2382 #endif
2383
2384                                         }
2385                                         else
2386                                         {
2387                                                 mon_fight = TRUE;
2388                                         }
2389                                 }
2390
2391                                 dam = damroll(15, 15);
2392                                 if (((randint0(100 + rlev/2) < (tr_ptr->level + 35)) && (m_ptr->r_idx != MON_KENSHIROU)) ||
2393                                          (tr_ptr->flags3 & RF3_RES_ALL))
2394                                 {
2395                                         /* Memorize a flag */
2396                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
2397                                         {
2398                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
2399                                         }
2400 #ifdef JP
2401 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
2402 #else
2403                                         if (see_both) msg_format("%^s resists!", t_name);
2404 #endif
2405
2406                                 }
2407                                 else
2408                                 {
2409                                         mon_take_hit_mon(FALSE, t_idx, dam, &fear, NULL, m_idx);
2410                                 }
2411
2412                                 wake_up = TRUE;
2413
2414                                 break;
2415                         }
2416
2417                         /* RF5_BO_ACID */
2418                         case 128+16:
2419                         {
2420                                 if (known)
2421                                 {
2422                                         if (see_either)
2423                                         {
2424 #ifdef JP
2425 msg_format("%s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¢¥·¥Ã¥É¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2426 #else
2427                                                 msg_format("%^s casts an acid bolt at %s.", m_name, t_name);
2428 #endif
2429
2430                                         }
2431                                         else
2432                                         {
2433                                                 mon_fight = TRUE;
2434                                         }
2435                                 }
2436
2437                                 dam = (damroll(7, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2438                                 monst_bolt_monst(m_idx, y, x, GF_ACID,
2439                                         dam, MS_BOLT_ACID, learnable);
2440
2441                                 break;
2442                         }
2443
2444                         /* RF5_BO_ELEC */
2445                         case 128+17:
2446                         {
2447                                 if (known)
2448                                 {
2449                                         if (see_either)
2450                                         {
2451 #ifdef JP
2452 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥µ¥ó¥À¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2453 #else
2454                                                 msg_format("%^s casts a lightning bolt at %s.", m_name, t_name);
2455 #endif
2456
2457                                         }
2458                                         else
2459                                         {
2460                                                 mon_fight = TRUE;
2461                                         }
2462                                 }
2463
2464                                 dam = (damroll(4, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2465                                 monst_bolt_monst(m_idx, y, x, GF_ELEC,
2466                                         dam, MS_BOLT_ELEC, learnable);
2467
2468                                 break;
2469                         }
2470
2471                         /* RF5_BO_FIRE */
2472                         case 128+18:
2473                         {
2474                                 if (known)
2475                                 {
2476                                         if (see_either)
2477                                         {
2478 #ifdef JP
2479 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥Õ¥¡¥¤¥¢¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2480 #else
2481                                                 msg_format("%^s casts a fire bolt at %s.", m_name, t_name);
2482 #endif
2483
2484                                         }
2485                                         else
2486                                         {
2487                                                 mon_fight = TRUE;
2488                                         }
2489                                 }
2490
2491                                 dam = (damroll(9, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2492                                 monst_bolt_monst(m_idx, y, x, GF_FIRE,
2493                                         dam, MS_BOLT_FIRE, learnable);
2494
2495                                 break;
2496                         }
2497
2498                         /* RF5_BO_COLD */
2499                         case 128+19:
2500                         {
2501                                 if (known)
2502                                 {
2503                                         if (see_either)
2504                                         {
2505 #ifdef JP
2506 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¢¥¤¥¹¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2507 #else
2508                                                 msg_format("%^s casts a frost bolt at %s.", m_name, t_name);
2509 #endif
2510
2511                                         }
2512                                         else
2513                                         {
2514                                                 mon_fight = TRUE;
2515                                         }
2516                                 }
2517
2518                                 dam = (damroll(6, 8) + (rlev / 3)) * ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 1);
2519                                 monst_bolt_monst(m_idx, y, x, GF_COLD,
2520                                         dam, MS_BOLT_COLD, learnable);
2521
2522                                 break;
2523                         }
2524
2525                         /* RF5_BA_LITE */
2526                         case 128+20:
2527                         {
2528                                 if (known)
2529                                 {
2530                                         if (see_either)
2531                                         {
2532                                                 disturb(1, 0);
2533
2534                                                 if (blind)
2535                                                 {
2536 #ifdef JP
2537 msg_format("%^s¤¬²¿¤«¤òÎÏ¶¯¤¯¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
2538 #else
2539                                                         msg_format("%^s mumbles powerfully.", m_name);
2540 #endif
2541
2542                                                 }
2543                                                 else
2544                                                 {
2545 #ifdef JP
2546 msg_format("%^s¤¬%s¤ËÂÐ¤·¤Æ¥¹¥¿¡¼¥Ð¡¼¥¹¥È¤Î¼öÊ¸¤òÇ°¤¸¤¿¡£", m_name, t_name);
2547 #else
2548                                                         msg_format("%^s invokes a starburst upon %s.", m_name, t_name);
2549 #endif
2550
2551                                                 }
2552                                         }
2553                                         else
2554                                         {
2555                                                 mon_fight = TRUE;
2556                                         }
2557                                 }
2558
2559                                 dam = (rlev * 4) + 50 + damroll(10, 10);
2560                                 monst_breath_monst(m_idx, y, x, GF_LITE, dam, 4, FALSE, MS_STARBURST, learnable);
2561
2562                                 break;
2563                         }
2564
2565                         /* RF5_BO_NETH */
2566                         case 128+21:
2567                         {
2568                                 if (known)
2569                                 {
2570                                         if (see_either)
2571                                         {
2572 #ifdef JP
2573 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤ÆÃÏ¹ö¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2574 #else
2575                                                 msg_format("%^s casts a nether bolt at %s.", m_name, t_name);
2576 #endif
2577
2578                                         }
2579                                         else
2580                                         {
2581                                                 mon_fight = TRUE;
2582                                         }
2583                                 }
2584
2585                                 dam = 30 + damroll(5, 5) + (rlev * 4) / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3);
2586                                 monst_bolt_monst(m_idx, y, x, GF_NETHER,
2587                                         dam, MS_BOLT_NETHER, learnable);
2588
2589                                 break;
2590                         }
2591
2592                         /* RF5_BO_WATE */
2593                         case 128+22:
2594                         {
2595                                 if (known)
2596                                 {
2597                                         if (see_either)
2598                                         {
2599 #ifdef JP
2600 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥¦¥©¡¼¥¿¡¼¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2601 #else
2602                                                 msg_format("%^s casts a water bolt at %s.", m_name, t_name);
2603 #endif
2604
2605                                         }
2606                                         else
2607                                         {
2608                                                 mon_fight = TRUE;
2609                                         }
2610                                 }
2611
2612                                 dam = damroll(10, 10) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
2613                                 monst_bolt_monst(m_idx, y, x, GF_WATER,
2614                                         dam, MS_BOLT_WATER, learnable);
2615
2616                                 break;
2617                         }
2618
2619                         /* RF5_BO_MANA */
2620                         case 128+23:
2621                         {
2622                                 if (known)
2623                                 {
2624                                         if (see_either)
2625                                         {
2626 #ifdef JP
2627 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤ÆËâÎÏ¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2628 #else
2629                                                 msg_format("%^s casts a mana bolt at %s.", m_name, t_name);
2630 #endif
2631
2632                                         }
2633                                         else
2634                                         {
2635                                                 mon_fight = TRUE;
2636                                         }
2637                                 }
2638
2639                                 dam = randint1(rlev * 7 / 2) + 50;
2640                                 monst_bolt_monst(m_idx, y, x, GF_MANA,
2641                                         dam, MS_BOLT_MANA, learnable);
2642
2643                                 break;
2644                         }
2645
2646                         /* RF5_BO_PLAS */
2647                         case 128+24:
2648                         {
2649                                 if (known)
2650                                 {
2651                                         if (see_either)
2652                                         {
2653 #ifdef JP
2654 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥×¥é¥º¥Þ¡¦¥Ü¥ë¥È¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2655 #else
2656                                                 msg_format("%^s casts a plasma bolt at %s.", m_name, t_name);
2657 #endif
2658
2659                                         }
2660                                         else
2661                                         {
2662                                                 mon_fight = TRUE;
2663                                         }
2664                                 }
2665
2666                                 dam = 10 + damroll(8, 7) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
2667                                 monst_bolt_monst(m_idx, y, x, GF_PLASMA,
2668                                         dam, MS_BOLT_PLASMA, learnable);
2669
2670                                 break;
2671                         }
2672
2673                         /* RF5_BO_ICEE */
2674                         case 128+25:
2675                         {
2676                                 if (known)
2677                                 {
2678                                         if (see_either)
2679                                         {
2680 #ifdef JP
2681 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¶Ë´¨¤ÎÌð¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2682 #else
2683                                                 msg_format("%^s casts an ice bolt at %s.", m_name, t_name);
2684 #endif
2685
2686                                         }
2687                                         else
2688                                         {
2689                                                 mon_fight = TRUE;
2690                                         }
2691                                 }
2692
2693                                 dam = damroll(6, 6) + (rlev * 3 / ((r_ptr->flags2 & RF2_POWERFUL) ? 2 : 3));
2694                                 monst_bolt_monst(m_idx, y, x, GF_ICE,
2695                                         dam, MS_BOLT_ICE, learnable);
2696
2697                                 break;
2698                         }
2699
2700                         /* RF5_MISSILE */
2701                         case 128+26:
2702                         {
2703                                 if (known)
2704                                 {
2705                                         if (see_either)
2706                                         {
2707 #ifdef JP
2708 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¥Þ¥¸¥Ã¥¯¡¦¥ß¥µ¥¤¥ë¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name, t_name);
2709 #else
2710                                                 msg_format("%^s casts a magic missile at %s.", m_name, t_name);
2711 #endif
2712
2713                                         }
2714                                         else
2715                                         {
2716                                                 mon_fight = TRUE;
2717                                         }
2718                                 }
2719
2720                                 dam = damroll(2, 6) + (rlev / 3);
2721                                 monst_bolt_monst(m_idx, y, x, GF_MISSILE,
2722                                         dam, MS_MAGIC_MISSILE, learnable);
2723
2724                                 break;
2725                         }
2726
2727                         /* RF5_SCARE */
2728                         case 128+27:
2729                         {
2730                                 if (known)
2731                                 {
2732                                         if (see_either)
2733                                         {
2734 #ifdef JP
2735 msg_format("%^s¤¬¶²¤í¤·¤²¤Ê¸¸³Ð¤òºî¤ê½Ð¤·¤¿¡£", m_name, t_name);
2736 #else
2737                                                 msg_format("%^s casts a fearful illusion in front of %s.", m_name, t_name);
2738 #endif
2739
2740                                         }
2741                                         else
2742                                         {
2743                                                 mon_fight = TRUE;
2744                                         }
2745                                 }
2746
2747                                 if (tr_ptr->flags3 & RF3_NO_FEAR)
2748                                 {
2749 #ifdef JP
2750 if (see_t) msg_format("%^s¤Ï¶²ÉÝ¤ò´¶¤¸¤Ê¤¤¡£", t_name);
2751 #else
2752                                         if (see_t) msg_format("%^s refuses to be frightened.", t_name);
2753 #endif
2754
2755                                 }
2756                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2757                                 {
2758 #ifdef JP
2759 if (see_t) msg_format("%^s¤Ï¶²ÉÝ¤ò´¶¤¸¤Ê¤¤¡£", t_name);
2760 #else
2761                                         if (see_t) msg_format("%^s refuses to be frightened.", t_name);
2762 #endif
2763
2764                                 }
2765                                 else
2766                                 {
2767                                         if (!t_ptr->monfear) fear = TRUE;
2768
2769                                         t_ptr->monfear += randint0(4) + 4;
2770                                 }
2771
2772                                 wake_up = TRUE;
2773
2774                                 break;
2775                         }
2776
2777                         /* RF5_BLIND */
2778                         case 128+28:
2779                         {
2780                                 if (known)
2781                                 {
2782                                         if (see_either)
2783                                         {
2784 #ifdef JP
2785 msg_format("%s¤Ï¼öÊ¸¤ò¾§¤¨¤Æ%s¤ÎÌÜ¤ò¾Æ¤ÉÕ¤«¤»¤¿¡£", m_name, t_name);
2786 #else
2787                                                 msg_format("%^s casts a spell, burning %s%s eyes.", m_name, t_name,
2788                                                                           (streq(t_name, "it") ? "s" : "'s"));
2789 #endif
2790
2791                                         }
2792                                         else
2793                                         {
2794                                                 mon_fight = TRUE;
2795                                         }
2796                                 }
2797
2798                                 /* Simulate blindness with confusion */
2799                                 if (tr_ptr->flags3 & RF3_NO_CONF)
2800                                 {
2801 #ifdef JP
2802 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2803 #else
2804                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2805 #endif
2806
2807                                 }
2808                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2809                                 {
2810 #ifdef JP
2811 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2812 #else
2813                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2814 #endif
2815
2816                                 }
2817                                 else
2818                                 {
2819 #ifdef JP
2820 if (see_t)   msg_format("%^s¤ÏÌÜ¤¬¸«¤¨¤Ê¤¯¤Ê¤Ã¤¿¡ª ", t_name);
2821 #else
2822                                         if (see_t) msg_format("%^s is blinded!", t_name);
2823 #endif
2824
2825
2826                                         t_ptr->confused += 12 + (byte)randint0(4);
2827                                 }
2828
2829                                 wake_up = TRUE;
2830
2831                                 break;
2832                         }
2833
2834                         /* RF5_CONF */
2835                         case 128+29:
2836                         {
2837                                 if (known)
2838                                 {
2839                                         if (see_either)
2840                                         {
2841 #ifdef JP
2842 msg_format("%^s¤¬%s¤ÎÁ°¤Ë¸¸ÏÇÅª¤Ê¸¸¤ò¤Ä¤¯¤ê½Ð¤·¤¿¡£", m_name, t_name);
2843 #else
2844                                                 msg_format("%^s casts a mesmerizing illusion in front of %s.", m_name, t_name);
2845 #endif
2846
2847                                         }
2848                                         else
2849                                         {
2850                                                 mon_fight = TRUE;
2851                                         }
2852                                 }
2853
2854                                 if (tr_ptr->flags3 & RF3_NO_CONF)
2855                                 {
2856 #ifdef JP
2857 if (see_t) msg_format("%^s¤ÏÏÇ¤ï¤µ¤ì¤Ê¤«¤Ã¤¿¡£", t_name);
2858 #else
2859                                         if (see_t) msg_format("%^s disbelieves the feeble spell.", t_name);
2860 #endif
2861
2862                                 }
2863                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2864                                 {
2865 #ifdef JP
2866 if (see_t) msg_format("%^s¤ÏÏÇ¤ï¤µ¤ì¤Ê¤«¤Ã¤¿¡£", t_name);
2867 #else
2868                                         if (see_t) msg_format("%^s disbelieves the feeble spell.", t_name);
2869 #endif
2870
2871                                 }
2872                                 else
2873                                 {
2874 #ifdef JP
2875 if (see_t) msg_format("%^s¤Ïº®Íð¤·¤¿¤è¤¦¤À¡£", t_name);
2876 #else
2877                                         if (see_t) msg_format("%^s seems confused.", t_name);
2878 #endif
2879
2880
2881                                         t_ptr->confused += 12 + (byte)randint0(4);
2882                                 }
2883
2884                                 wake_up = TRUE;
2885
2886                                 break;
2887                         }
2888
2889                         /* RF5_SLOW */
2890                         case 128+30:
2891                         {
2892                                 if (known)
2893                                 {
2894                                         if (see_either)
2895                                         {
2896 #ifdef JP
2897 msg_format("%s¤¬%s¤Î¶ÚÆù¤«¤éÎÏ¤òµÛ¤¤¤È¤Ã¤¿¡£", m_name, t_name);
2898 #else
2899                                                 msg_format("%^s drains power from %s%s muscles.", m_name, t_name,
2900                                                                           (streq(t_name, "it") ? "s" : "'s"));
2901 #endif
2902
2903                                         }
2904                                         else
2905                                         {
2906                                                 mon_fight = TRUE;
2907                                         }
2908                                 }
2909
2910                                 if (tr_ptr->flags1 & RF1_UNIQUE)
2911                                 {
2912 #ifdef JP
2913 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2914 #else
2915                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2916 #endif
2917
2918                                 }
2919                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2920                                 {
2921 #ifdef JP
2922 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2923 #else
2924                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2925 #endif
2926
2927                                 }
2928                                 else
2929                                 {
2930                                         if (!t_ptr->slow)
2931                                         {
2932 #ifdef JP
2933 if (see_t) msg_format("%s¤ÎÆ°¤¤¬ÃÙ¤¯¤Ê¤Ã¤¿¡£", t_name);
2934 #else
2935                                         if (see_t) msg_format("%^s starts moving slower.", t_name);
2936 #endif
2937                                         }
2938
2939                                         t_ptr->slow = MIN(200, t_ptr->slow + 50);
2940                                 }
2941
2942                                 wake_up = TRUE;
2943
2944                                 break;
2945                         }
2946
2947                         /* RF5_HOLD */
2948                         case 128+31:
2949                         {
2950                                 if (known)
2951                                 {
2952                                         if (see_either)
2953                                         {
2954 #ifdef JP
2955 msg_format("%^s¤Ï%s¤ò¤¸¤Ã¤È¸«¤Ä¤á¤¿¡£", m_name, t_name);
2956 #else
2957                                                 msg_format("%^s stares intently at %s.", m_name, t_name);
2958 #endif
2959
2960                                         }
2961                                         else
2962                                         {
2963                                                 mon_fight = TRUE;
2964                                         }
2965                                 }
2966
2967                                 if ((tr_ptr->flags1 & RF1_UNIQUE) ||
2968                                          (tr_ptr->flags3 & RF3_NO_STUN))
2969                                 {
2970 #ifdef JP
2971 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2972 #else
2973                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2974 #endif
2975
2976                                 }
2977                                 else if (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10)
2978                                 {
2979 #ifdef JP
2980 if (see_t) msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
2981 #else
2982                                         if (see_t) msg_format("%^s is unaffected.", t_name);
2983 #endif
2984
2985                                 }
2986                                 else
2987                                 {
2988 #ifdef JP
2989 if (see_t) msg_format("%^s¤ÏËãáã¤·¤¿¡ª", t_name);
2990 #else
2991                                         if (see_t) msg_format("%^s is paralyzed!", t_name);
2992 #endif
2993
2994
2995                                         t_ptr->stunned += randint1(4) + 4;
2996                                 }
2997
2998                                 wake_up = TRUE;
2999
3000                                 break;
3001                         }
3002
3003
3004                         /* RF6_HASTE */
3005                         case 160+0:
3006                         {
3007                                 if (known)
3008                                 {
3009                                         if (see_m)
3010                                         {
3011 #ifdef JP
3012 msg_format("%^s¤¬¼«Ê¬¤ÎÂÎ¤ËÇ°¤òÁ÷¤Ã¤¿¡£", m_name, m_poss);
3013 #else
3014                                                 msg_format("%^s concentrates on %s body.", m_name, m_poss);
3015 #endif
3016
3017                                         }
3018                                         else
3019                                         {
3020                                                 mon_fight = TRUE;
3021                                         }
3022                                 }
3023
3024                                 /* Allow quick speed increases to base+10 */
3025                                 if (!m_ptr->fast)
3026                                 {
3027 #ifdef JP
3028 if (see_m) msg_format("%^s¤ÎÆ°¤¤¬Â®¤¯¤Ê¤Ã¤¿¡£", m_name);
3029 #else
3030                                         if (see_m) msg_format("%^s starts moving faster.", m_name);
3031 #endif
3032
3033                                 }
3034                                 m_ptr->fast = MIN(200, m_ptr->fast + 100);
3035                                 if (p_ptr->riding == m_idx) p_ptr->update |= PU_BONUS;
3036                                 break;
3037                         }
3038
3039                         /* RF6_HAND_DOOM */
3040                         case 160+1:
3041                         {
3042                                 if (known)
3043                                 {
3044                                         if (see_m)
3045                                         {
3046 #ifdef JP
3047 msg_format("%^s¤¬%s¤Ë<ÇËÌÇ¤Î¼ê>¤òÊü¤Ã¤¿¡ª", m_name, t_name);
3048 #else
3049                                                 msg_format("%^s invokes the Hand of Doom upon %s!", m_name, t_name);
3050 #endif
3051
3052                                         }
3053                                         else
3054                                         {
3055                                                 mon_fight = TRUE;
3056                                         }
3057                                 }
3058
3059                                 if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flags3 & RF3_RES_ALL))
3060                                 {
3061                                         /* Memorize a flag */
3062                                         if (tr_ptr->flags3 & (RF3_RES_ALL))
3063                                         {
3064                                                 tr_ptr->r_flags3 |= (RF3_RES_ALL);
3065                                         }
3066 #ifdef JP
3067 if (see_both) msg_format("¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡ª", t_name);
3068 #else
3069                                         if (see_both) msg_format("^%s is unaffected!", t_name);
3070 #endif
3071
3072                                 }
3073                                 else
3074                                 {
3075                                         if ((r_ptr->level + randint1(20)) >
3076                                                 (tr_ptr->level + 10 + randint1(20)))
3077                                         {
3078                                                 t_ptr->hp = t_ptr->hp -
3079                                                   (((s32b)((40 + randint1(20)) * t_ptr->hp)) / 100);
3080
3081                                                 if (t_ptr->hp < 1) t_ptr->hp = 1;
3082                                         }
3083                                         else
3084                                         {
3085 #ifdef JP
3086 if (see_both) msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
3087 #else
3088                                                 if (see_both) msg_format("%^s resists!", t_name);
3089 #endif
3090
3091                                         }
3092                                 }
3093
3094                                 wake_up = TRUE;
3095
3096                                 break;
3097                         }
3098
3099                         /* RF6_HEAL */
3100                         case 160+2:
3101                         {
3102                                 if (known)
3103                                 {
3104                                         if (see_m)
3105                                         {
3106 #ifdef JP
3107 msg_format("%^s¤Ï¼«Ê¬¤Î½ý¤ËÇ°¤ò½¸Ãæ¤·¤¿¡£", m_name);
3108 #else
3109                                                 msg_format("%^s concentrates on %s wounds.", m_name, m_poss);
3110 #endif
3111
3112                                         }
3113                                         else
3114                                         {
3115                                                 mon_fight = TRUE;
3116                                         }
3117                                 }
3118
3119                                 /* Heal some */
3120                                 m_ptr->hp += (rlev * 6);
3121
3122                                 /* Fully healed */
3123                                 if (m_ptr->hp >= m_ptr->maxhp)
3124                                 {
3125                                         /* Fully healed */
3126                                         m_ptr->hp = m_ptr->maxhp;
3127
3128                                         if (known)
3129                                         {
3130                                                 if (see_m)
3131                                                 {
3132 #ifdef JP
3133 msg_format("%^s¤Ï´°Á´¤Ë¼£¤Ã¤¿¡ª", m_name);
3134 #else
3135                                                         msg_format("%^s looks completely healed!", m_name);
3136 #endif
3137
3138                                                 }
3139                                                 else
3140                                                 {
3141                                                         mon_fight = TRUE;
3142                                                 }
3143                                         }
3144                                 }
3145
3146                                 /* Partially healed */
3147                                 else if (known)
3148                                 {
3149                                         if (see_m)
3150                                         {
3151 #ifdef JP
3152 msg_format("%^s¤ÏÂÎÎÏ¤ò²óÉü¤·¤¿¤è¤¦¤À¡£", m_name);
3153 #else
3154                                                 msg_format("%^s looks healthier.", m_name);
3155 #endif
3156
3157                                         }
3158                                         else
3159                                         {
3160                                                 mon_fight = TRUE;
3161                                         }
3162                                 }
3163
3164                                 /* Redraw (later) if needed */
3165                                 if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
3166                                 if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
3167
3168                                 /* Cancel fear */
3169                                 if (m_ptr->monfear)
3170                                 {
3171                                         /* Cancel fear */
3172                                         m_ptr->monfear = 0;
3173
3174                                         /* Message */
3175 #ifdef JP
3176 if (see_m) msg_format("%^s¤ÏÍ¦µ¤¤ò¼è¤êÌá¤·¤¿¡£", m_name);
3177 #else
3178                                         if (see_m) msg_format("%^s recovers %s courage.", m_name, m_poss);
3179 #endif
3180
3181                                 }
3182
3183                                 break;
3184                         }
3185
3186                         /* RF6_INVULNER */
3187                         case 160+3:
3188                         {
3189                                 if (known)
3190                                 {
3191                                         if (see_m)
3192                                         {
3193                                                 disturb(1, 0);
3194 #ifdef JP
3195 msg_format("%s¤ÏÌµ½ý¤Îµå¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3196 #else
3197                                                 msg_format("%^s casts a Globe of Invulnerability.", m_name);
3198 #endif
3199
3200                                         }
3201                                         else
3202                                         {
3203                                                 mon_fight = TRUE;
3204                                         }
3205                                 }
3206
3207                                 if (!m_ptr->invulner) m_ptr->invulner = randint1(4) + 4;
3208
3209                                 if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
3210                                 if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
3211                                 break;
3212                         }
3213
3214                         /* RF6_BLINK */
3215                         case 160+4:
3216                         {
3217                                 if (see_m)
3218                                 {
3219 #ifdef JP
3220 msg_format("%^s¤¬½Ö»þ¤Ë¾Ã¤¨¤¿¡£", m_name);
3221 #else
3222                                         msg_format("%^s blinks away.", m_name);
3223 #endif
3224
3225                                 }
3226
3227                                 teleport_away(m_idx, 10, FALSE);
3228
3229                                 break;
3230                         }
3231
3232                         /* RF6_TPORT */
3233                         case 160+5:
3234                         {
3235                                 int i, oldfy, oldfx;
3236                                 u32b flgs[TR_FLAG_SIZE];
3237                                 object_type *o_ptr;
3238
3239                                 oldfy = m_ptr->fy;
3240                                 oldfx = m_ptr->fx;
3241
3242                                 if (see_m)
3243                                 {
3244 #ifdef JP
3245 msg_format("%^s¤¬¥Æ¥ì¥Ý¡¼¥È¤·¤¿¡£", m_name);
3246 #else
3247                                         msg_format("%^s teleports away.", m_name);
3248 #endif
3249
3250                                 }
3251
3252                                 teleport_away(m_idx, MAX_SIGHT * 2 + 5, FALSE);
3253
3254                                 if (los(py, px, oldfy, oldfx) && !world_monster && see_m)
3255                                 {
3256                                         for (i=INVEN_RARM;i<INVEN_TOTAL;i++)
3257                                         {
3258                                                 o_ptr = &inventory[i];
3259                                                 if(!cursed_p(o_ptr))
3260                                                 {
3261                                                         object_flags(o_ptr, flgs);
3262
3263                                                         if((have_flag(flgs, TR_TELEPORT)) || (p_ptr->muta1 & MUT1_VTELEPORT) || (p_ptr->pclass == CLASS_IMITATOR))
3264                                                         {
3265 #ifdef JP
3266                                                                 if(get_check_strict("¤Ä¤¤¤Æ¤¤¤¤Þ¤¹¤«¡©", CHECK_OKAY_CANCEL))
3267 #else
3268                                                                 if(get_check_strict("Do you follow it? ", CHECK_OKAY_CANCEL))
3269 #endif
3270                                                                 {
3271                                                                         if (one_in_(3))
3272                                                                         {
3273                                                                                 teleport_player(200);
3274 #ifdef JP
3275                                                                                 msg_print("¼ºÇÔ¡ª");
3276 #else
3277                                                                                 msg_print("Failed!");
3278 #endif
3279                                                                         }
3280                                                                         else teleport_player_to(m_ptr->fy, m_ptr->fx, TRUE);
3281                                                                         p_ptr->energy_need = ENERGY_NEED();
3282                                                                 }
3283                                                                 break;
3284                                                         }
3285                                                 }
3286                                         }
3287                                 }
3288                                 break;
3289                         }
3290
3291                         /* RF6_WORLD */
3292                         case 160+6:
3293                         {
3294 #if 0
3295                                 int who = 0;
3296                                 if(m_ptr->r_idx = MON_DIO) who == 1;
3297                                 else if(m_ptr->r_idx = MON_WONG) who == 3;
3298                                 dam = who;
3299                                 if(!process_the_world(randint1(2)+2, who, los(py, px, m_ptr->fy, m_ptr->fx))) return (FALSE);
3300 #endif
3301                                 return FALSE;
3302                         }
3303
3304                         /* RF6_SPECIAL */
3305                         case 160+7:
3306                         {
3307                                 int k;
3308                                 if (p_ptr->inside_arena || p_ptr->inside_battle) return FALSE;
3309                                 switch(m_ptr->r_idx)
3310                                 {
3311                                         case MON_OHMU:
3312                                         {
3313                                                 for (k = 0; k < 6; k++)
3314                                                 {
3315                                                         summon_specific(m_idx, m_ptr->fy, m_ptr->fx, rlev, SUMMON_BIZARRE1, PM_ALLOW_GROUP);
3316                                                 }
3317                                                 return FALSE;
3318                                         }
3319                                 default:
3320                                         if (r_ptr->d_char == 'B')
3321                                         {
3322                                                 if (one_in_(3))
3323                                                 {
3324                                                         if (see_m)
3325                                                         {
3326 #ifdef JP
3327                                                                 msg_format("%^s¤ÏÆÍÁ³µÞ¾å¾º¤·¤Æ»ë³¦¤«¤é¾Ã¤¨¤¿!", m_name);
3328 #else
3329                                                                 msg_format("%^s suddenly go out of your sight!", m_name);
3330 #endif
3331                                                         }
3332                                                         teleport_away(m_idx, 10, FALSE);
3333                                                         p_ptr->update |= (PU_MONSTERS | PU_MON_LITE);
3334                                                         break;
3335                                                 }
3336                                                 else
3337                                                 {
3338                                                         /* Not implemented */
3339                                                         return FALSE;
3340                                                 }
3341                                                 break;
3342                                         }
3343
3344                                         /* Something is wrong */
3345                                         else return FALSE;
3346                                 }
3347
3348                                 /* done */
3349                                 break;
3350                         }
3351                         /* RF6_TELE_TO */
3352                         case 160+8:
3353                         {
3354                                 /* Not implemented */
3355                                 return FALSE;
3356                         }
3357
3358                         /* RF6_TELE_AWAY */
3359                         case 160+9:
3360                         {
3361                                 bool resists_tele = FALSE;
3362
3363                                 if (known)
3364                                 {
3365                                         if (see_either)
3366                                         {
3367 #ifdef JP
3368 msg_format("%^s¤Ï%s¤ò¥Æ¥ì¥Ý¡¼¥È¤µ¤»¤¿¡£", m_name, t_name);
3369 #else
3370                                                 msg_format("%^s teleports %s away.", m_name, t_name);
3371 #endif
3372
3373                                         }
3374                                         else
3375                                         {
3376                                                 mon_fight = TRUE;
3377                                         }
3378                                 }
3379
3380                                 if (tr_ptr->flags3 & RF3_RES_TELE)
3381                                 {
3382                                         if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flags3 & (RF3_RES_ALL)))
3383                                         {
3384                                                 if (see_t)
3385                                                 {
3386                                                         tr_ptr->r_flags3 |= RF3_RES_TELE;
3387 #ifdef JP
3388 msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", t_name);
3389 #else
3390                                                         msg_format("%^s is unaffected!", t_name);
3391 #endif
3392
3393                                                 }
3394
3395                                                 resists_tele = TRUE;
3396                                         }
3397                                         else if (tr_ptr->level > randint1(100))
3398                                         {
3399                                                 if (see_t)
3400                                                 {
3401                                                         tr_ptr->r_flags3 |= RF3_RES_TELE;
3402 #ifdef JP
3403 msg_format("%^s¤ÏÂÑÀ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", t_name);
3404 #else
3405                                                         msg_format("%^s resists!", t_name);
3406 #endif
3407
3408                                                 }
3409
3410                                                 resists_tele = TRUE;
3411                                         }
3412                                 }
3413
3414                                 if (!resists_tele)
3415                                 {
3416                                         if (t_idx == p_ptr->riding) teleport_player(MAX_SIGHT * 2 + 5);
3417                                         else teleport_away(t_idx, MAX_SIGHT * 2 + 5, FALSE);
3418                                 }
3419
3420                                 break;
3421                         }
3422
3423                         /* RF6_TELE_LEVEL */
3424                         case 160+10:
3425                         {
3426                                 /* Not implemented */
3427                                 return FALSE;
3428                         }
3429
3430                         /* RF6_PSY_SPEAR */
3431                         case 160+11:
3432                         {
3433                                 if (known)
3434                                 {
3435                                         if (see_either)
3436                                         {
3437 #ifdef JP
3438 msg_format("%^s¤¬%s¤Ë¸þ¤«¤Ã¤Æ¸÷¤Î·õ¤òÊü¤Ã¤¿¡£", m_name, t_name);
3439 #else
3440                                                 msg_format("%^s throw a Psycho-spear at %s.", m_name, t_name);
3441 #endif
3442
3443                                         }
3444                                         else
3445                                         {
3446                                                 mon_fight = TRUE;
3447                                         }
3448                                 }
3449
3450                                 dam = (r_ptr->flags2 & RF2_POWERFUL) ? (randint1(rlev * 2) + 180) : (randint1(rlev * 3 / 2) + 120);
3451                                 monst_beam_monst(m_idx, y, x, GF_PSY_SPEAR,
3452                                         dam, MS_PSY_SPEAR, learnable);
3453                                 break;
3454                         }
3455
3456                         /* RF6_DARKNESS */
3457                         case 160+12:
3458                         {
3459                                 if (known)
3460                                 {
3461                                         if (see_m)
3462                                         {
3463 #ifdef JP
3464 msg_format("%^s¤¬°Å°Ç¤ÎÃæ¤Ç¼ê¤ò¿¶¤Ã¤¿¡£", m_name);
3465 #else
3466                                                 msg_format("%^s gestures in shadow.", m_name);
3467 #endif
3468
3469
3470                                                 if (see_t)
3471                                                 {
3472 #ifdef JP
3473 msg_format("%^s¤Ï°Å°Ç¤ËÊñ¤Þ¤ì¤¿¡£", t_name);
3474 #else
3475                                                         msg_format("%^s is surrounded by darkness.", t_name);
3476 #endif
3477
3478                                                 }
3479                                         }
3480                                         else
3481                                         {
3482                                                 mon_fight = TRUE;
3483                                         }
3484                                 }
3485
3486                                 (void)project(m_idx, 3, y, x, 0, GF_DARK_WEAK, PROJECT_GRID | PROJECT_KILL | PROJECT_MONSTER, MS_DARKNESS);
3487
3488                                 unlite_room(y, x);
3489
3490                                 break;
3491                         }
3492
3493                         /* RF6_TRAPS */
3494                         case 160+13:
3495                         {
3496 #if 0
3497                                 if (known)
3498                                 {
3499                                         if (see_m)
3500                                         {
3501 #ifdef JP
3502 msg_format("%^s¤¬¼öÊ¸¤ò¾§¤¨¤Æ¼Ù°¤ËÈù¾Ð¤ó¤À¡£", m_name);
3503 #else
3504                                                 msg_format("%^s casts a spell and cackles evilly.", m_name);
3505 #endif
3506                                         }
3507                                         else
3508                                         {
3509 #ifdef JP
3510 msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3511 #else
3512                                                 msg_format("%^s mumbles.", m_name);
3513 #endif
3514                                         }
3515                                 }
3516
3517                                 trap_creation(y, x);
3518 #endif
3519                                 break;
3520                         }
3521
3522                         /* RF6_FORGET */
3523                         case 160+14:
3524                         {
3525                                 /* Not implemented */
3526                                 return FALSE;
3527                         }
3528
3529                         /* RF6_RAISE_DEAD */
3530                         case 160+15:
3531                         {
3532                                 if (known)
3533                                 {
3534                                         if (see_either)
3535                                         {
3536                                                 disturb(1, 0);
3537 #ifdef JP
3538                                                 if (blind) msg_format("%^s¤¬²¿¤«¤ò¤Ä¤Ö¤ä¤¤¤¿¡£", m_name);
3539 #else
3540                                                 if (blind) msg_format("%^s mumbles.", m_name);
3541 #endif
3542
3543 #ifdef JP
3544                                                 else msg_format("%^s¤¬»à¼ÔÉü³è¤Î¼öÊ¸¤ò¾§¤¨¤¿¡£", m_name);
3545 #else
3546                                                 else msg_format("%^s casts a spell to revive corpses.", m_name);
3547 #endif
3548                                         }
3549                                         else
3550                                         {
3551                                                 mon_fight = TRUE;
3552                                         }
3553                                 }
3554                                 animate_dead(m_idx, m_ptr->fy, m_ptr->fx);
3555                                 break;
3556                         }
3557
3558                         /* RF6_SUMMON_KIN */
3559                         case 160+16:
3560                         {
3561                                 if (known)
3562                                 {
3563                                         if (see_either)
3564                                         {
3565                                                 disturb(1, 0);
3566
3567                                                 if (m_ptr->r_idx == MON_ROLENTO)
3568                                                 {
3569 #ifdef JP
3570                                                         msg_format("%^s¤Ï¼êÜØÃÆ¤ò¤Ð¤é¤Þ¤¤¤¿¡£",
3571                                                                 m_name);
3572 #else
3573                                                         msg_format("%^s throws some hand grenades.",
3574                                                                 m_name);
3575 #endif
3576                                                 }
3577                                                 else if (m_ptr->r_idx == MON_SERPENT || m_ptr->r_idx == MON_ZOMBI_SERPENT)
3578                                                 {
3579 #ifdef JP
3580                                                         msg_format("%^s¤¬¥À¥ó¥¸¥ç¥ó¤Î¼ç¤ò¾¤´¤·¤¿¡£", m_name);
3581 #else
3582                                                         msg_format("%^s magically summons guardians of dungeons.", m_name);
3583 #endif
3584                                                 }
3585                                                 else
3586                                                 {
3587 #ifdef JP
3588 msg_format("%s¤¬ËâË¡¤Ç%s¤ò¾¤´¤·¤¿¡£", m_name,
3589   ((r_ptr->flags1 & RF1_UNIQUE) ? "¼ê²¼" : "Ãç´Ö"));
3590 #else
3591                                                         msg_format("%^s magically summons %s %s.", m_name, m_poss,
3592                                                                           ((r_ptr->flags1 & RF1_UNIQUE) ? "minions" : "kin"));
3593 #endif
3594                                                 }
3595
3596                                         }
3597                                         else
3598                                         {
3599                                                 mon_fight = TRUE;
3600                                         }
3601                                 }
3602
3603                                 if(m_ptr->r_idx == MON_ROLENTO)
3604                                 {
3605                                         int num = 1 + randint1(3);
3606                                         for (k = 0; k < num; k++)
3607                                         {
3608                                                 count += summon_named_creature(m_idx, y, x, MON_SHURYUUDAN, p_mode);
3609                                         }
3610                                 }
3611                                 else if(m_ptr->r_idx == MON_THORONDOR ||
3612                                         m_ptr->r_idx == MON_GWAIHIR ||
3613                                         m_ptr->r_idx == MON_MENELDOR)
3614                                 {
3615                                         int num = 4 + randint1(3);
3616                                         for (k = 0; k < num; k++)
3617                                         {
3618                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_EAGLES, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | p_mode));
3619                                         }
3620                                 }
3621                                 else if(m_ptr->r_idx == MON_LOUSY)
3622                                 {
3623                                         int num = 2 + randint1(3);
3624                                         for (k = 0; k < num; k++)
3625                                         {
3626                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_LOUSE, (PM_ALLOW_GROUP | p_mode));
3627                                         }
3628                                 }
3629                                 else if(m_ptr->r_idx == MON_BULLGATES)
3630                                 {
3631                                         int num = 2 + randint1(3);
3632                                         for (k = 0; k < num; k++)
3633                                         {
3634                                                 count += summon_named_creature(m_idx, y, x, 921, p_mode);
3635                                         }
3636                                 }
3637                                 else if (m_ptr->r_idx == MON_CALDARM)
3638                                 {
3639                                         int num = randint1(3);
3640                                         for (k = 0; k < num; k++)
3641                                         {
3642                                                 count += summon_named_creature(m_idx, y, x, 930, p_mode);
3643                                         }
3644                                 }
3645                                 else if (m_ptr->r_idx == MON_SERPENT || m_ptr->r_idx == MON_ZOMBI_SERPENT)
3646                                 {
3647                                         int num = 2 + randint1(3);
3648                                         for (k = 0; k < num; k++)
3649                                         {
3650                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_GUARDIANS, (PM_ALLOW_GROUP | p_mode | PM_ALLOW_UNIQUE));
3651                                         }
3652                                 }
3653                                 else
3654                                 {
3655                                         summon_kin_type = r_ptr->d_char;
3656
3657                                         for (k = 0; k < 4; k++)
3658                                         {
3659                                                 count += summon_specific(m_idx, y, x, rlev, SUMMON_KIN, (PM_ALLOW_GROUP | p_mode));
3660                                         }
3661                                 }
3662
3663                                 if (known && !see_t && count)
3664                                 {
3665                                      mon_fight = TRUE;
3666                                 }
3667
3668                                 break;
3669                         }
3670
3671                         /* RF6_S_CYBER */
3672                         case 160+17:
3673                         {
3674                                 if (known)
3675                                 {
3676                                         if (see_either)
3677                                         {
3678                                                 disturb(1, 0);
3679
3680 #ifdef JP
3681 msg_format("%^s¤¬¥µ¥¤¥Ð¡¼¥Ç¡¼¥â¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
3682 #else
3683                                                 msg_format("%^s magically summons Cyberdemons!", m_name);
3684 #endif
3685
3686                                         }
3687                                         else
3688                                         {
3689                                                 mon_fight = TRUE;
3690                                         }
3691                                 }
3692
3693                                 if (is_friendly(m_ptr))
3694                                 {
3695                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_CYBER, (PM_ALLOW_GROUP | p_mode));
3696                                 }
3697                                 else
3698                                 {
3699                                         count += summon_cyber(m_idx, y, x);
3700                                 }
3701
3702                                 if (known && !see_t && count)
3703                                 {
3704                                      mon_fight = TRUE;
3705                                 }
3706
3707                                 break;
3708                         }
3709
3710                         /* RF6_S_MONSTER */
3711                         case 160+18:
3712                         {
3713                                 if (known)
3714                                 {
3715                                         if (see_either)
3716                                         {
3717                                                 disturb(1, 0);
3718
3719 #ifdef JP
3720 msg_format("%^s¤¬ËâË¡¤ÇÃç´Ö¤ò¾¤´¤·¤¿¡ª", m_name);
3721 #else
3722                                                 msg_format("%^s magically summons help!", m_name);
3723 #endif
3724
3725                                         }
3726                                         else
3727                                         {
3728                                                 mon_fight = TRUE;
3729                                         }
3730                                 }
3731
3732                                 count += summon_specific(m_idx, y, x, rlev, 0, (p_mode | u_mode));
3733
3734                                 if (known && !see_t && count)
3735                                 {
3736                                       mon_fight = TRUE;
3737                                 }
3738
3739                                 break;
3740                         }
3741
3742                         /* RF6_S_MONSTERS */
3743                         case 160+19:
3744                         {
3745                                 if (known)
3746                                 {
3747                                         if (see_either)
3748                                         {
3749                                                 disturb(1, 0);
3750
3751 #ifdef JP
3752 msg_format("%^s¤¬ËâË¡¤Ç¥â¥ó¥¹¥¿¡¼¤ò¾¤´¤·¤¿¡ª", m_name);
3753 #else
3754                                                 msg_format("%^s magically summons monsters!", m_name);
3755 #endif
3756
3757                                         }
3758                                         else
3759                                         {
3760                                                 mon_fight = TRUE;
3761                                         }
3762                                 }
3763
3764                                 for (k = 0; k < s_num_6; k++)
3765                                 {
3766                                         count += summon_specific(m_idx, y, x, rlev, 0, (PM_ALLOW_GROUP | p_mode | u_mode));
3767                                 }
3768
3769                                 if (known && !see_t && count)
3770                                 {
3771                                   mon_fight = TRUE;
3772                                 }
3773
3774                                 break;
3775                         }
3776
3777                         /* RF6_S_ANT */
3778                         case 160+20:
3779                         {
3780                                 if (known)
3781                                 {
3782                                         if (see_either)
3783                                         {
3784                                                 disturb(1, 0);
3785
3786 #ifdef JP
3787 msg_format("%^s¤¬ËâË¡¤Ç¥¢¥ê¤ò¾¤´¤·¤¿¡£", m_name);
3788 #else
3789                                                 msg_format("%^s magically summons ants.", m_name);
3790 #endif
3791
3792                                         }
3793                                         else
3794                                         {
3795                                                 mon_fight = TRUE;
3796                                         }
3797                                 }
3798
3799                                 for (k = 0; k < s_num_6; k++)
3800                                 {
3801                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_ANT, (PM_ALLOW_GROUP | p_mode));
3802                                 }
3803
3804                                 if (known && !see_t && count)
3805                                 {
3806                                      mon_fight = TRUE;
3807                                 }
3808
3809                                 break;
3810                         }
3811
3812                         /* RF6_S_SPIDER */
3813                         case 160+21:
3814                         {
3815                                 if (known)
3816                                 {
3817                                         if (see_either)
3818                                         {
3819                                                 disturb(1, 0);
3820
3821 #ifdef JP
3822 msg_format("%^s¤¬ËâË¡¤Ç¥¯¥â¤ò¾¤´¤·¤¿¡£", m_name);
3823 #else
3824                                                 msg_format("%^s magically summons spiders.", m_name);
3825 #endif
3826
3827                                         }
3828                                         else
3829                                         {
3830                                                 mon_fight = TRUE;
3831                                         }
3832                                 }
3833
3834                                 for (k = 0; k < s_num_6; k++)
3835                                 {
3836                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_SPIDER, (PM_ALLOW_GROUP | p_mode));
3837                                 }
3838
3839                                 if (known && !see_t && count)
3840                                 {
3841                                     mon_fight = TRUE;
3842                                 }
3843
3844                                 break;
3845                         }
3846
3847                         /* RF6_S_HOUND */
3848                         case 160+22:
3849                         {
3850                                 if (known)
3851                                 {
3852                                         if (see_either)
3853                                         {
3854                                                 disturb(1, 0);
3855
3856 #ifdef JP
3857 msg_format("%^s¤¬ËâË¡¤Ç¥Ï¥¦¥ó¥É¤ò¾¤´¤·¤¿¡£", m_name);
3858 #else
3859                                                 msg_format("%^s magically summons hounds.", m_name);
3860 #endif
3861
3862                                         }
3863                                         else
3864                                         {
3865                                                 mon_fight = TRUE;
3866                                         }
3867                                 }
3868
3869                                 for (k = 0; k < s_num_4; k++)
3870                                 {
3871                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HOUND, (PM_ALLOW_GROUP | p_mode));
3872                                 }
3873
3874                                 if (known && !see_t && count)
3875                                 {
3876                                      mon_fight = TRUE;
3877                                 }
3878
3879                                 break;
3880                         }
3881
3882                         /* RF6_S_HYDRA */
3883                         case 160+23:
3884                         {
3885                                 if (known)
3886                                 {
3887                                         if (see_either)
3888                                         {
3889                                                 disturb(1, 0);
3890
3891 #ifdef JP
3892 msg_format("%^s¤¬ËâË¡¤Ç¥Ò¥É¥é¤ò¾¤´¤·¤¿¡£", m_name);
3893 #else
3894                                                 msg_format("%^s magically summons hydras.", m_name);
3895 #endif
3896
3897                                         }
3898                                         else
3899                                         {
3900                                                 mon_fight = TRUE;
3901                                         }
3902                                 }
3903
3904                                 for (k = 0; k < s_num_4; k++)
3905                                 {
3906                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HYDRA, (PM_ALLOW_GROUP | p_mode));
3907                                 }
3908
3909                                 if (known && !see_t && count)
3910                                 {
3911                                     mon_fight = TRUE;
3912                                 }
3913
3914                                 break;
3915                         }
3916
3917                         /* RF6_S_ANGEL */
3918                         case 160+24:
3919                         {
3920                                 int num = 1;
3921                                 if (known)
3922                                 {
3923                                         if (see_either)
3924                                         {
3925                                                 disturb(1, 0);
3926
3927 #ifdef JP
3928 msg_format("%^s¤¬ËâË¡¤ÇÅ·»È¤ò¾¤´¤·¤¿¡ª", m_name);
3929 #else
3930                                                 msg_format("%^s magically summons an angel!", m_name);
3931 #endif
3932
3933                                         }
3934                                         else
3935                                         {
3936                                                 mon_fight = TRUE;
3937                                         }
3938                                 }
3939
3940                                 if ((r_ptr->flags1 & RF1_UNIQUE) && !easy_band)
3941                                 {
3942                                         num += r_ptr->level/40;
3943                                 }
3944
3945                                 for (k = 0; k < num; k++)
3946                                 {
3947                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_ANGEL, (PM_ALLOW_GROUP | p_mode));
3948                                 }
3949
3950                                 if (known && !see_t && count)
3951                                 {
3952                                    mon_fight = TRUE;
3953                                 }
3954
3955                                 break;
3956                         }
3957
3958                         /* RF6_S_DEMON */
3959                         case 160+25:
3960                         {
3961                                 if (known)
3962                                 {
3963                                         if (see_either)
3964                                         {
3965                                                 disturb(1, 0);
3966
3967 #ifdef JP
3968 msg_format("%^s¤¬ËâË¡¤Çº®ÆÙ¤ÎµÜÄî¤«¤é¥Ç¡¼¥â¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
3969 #else
3970                                                 msg_format("%^s magically summons a demon from the Courts of Chaos!", m_name);
3971 #endif
3972
3973                                         }
3974                                         else
3975                                         {
3976                                                 mon_fight = TRUE;
3977                                         }
3978                                 }
3979
3980                                 for (k = 0; k < 1; k++)
3981                                 {
3982                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_DEMON, (PM_ALLOW_GROUP | p_mode));
3983                                 }
3984
3985                                 if (known && !see_t && count)
3986                                 {
3987                                     mon_fight = TRUE;
3988                                 }
3989
3990                                 break;
3991                         }
3992
3993                         /* RF6_S_UNDEAD */
3994                         case 160+26:
3995                         {
3996                                 if (known)
3997                                 {
3998                                         if (see_either)
3999                                         {
4000                                                 disturb(1, 0);
4001
4002 #ifdef JP
4003 msg_format("%s¤¬ËâË¡¤Ç¥¢¥ó¥Ç¥Ã¥É¤ò¾¤´¤·¤¿¡£", m_name);
4004 #else
4005                                                 msg_format("%^s magically summons undead.", m_name);
4006 #endif
4007
4008                                         }
4009                                         else
4010                                         {
4011                                                 mon_fight = TRUE;
4012                                         }
4013                                 }
4014
4015                                 for (k = 0; k < 1; k++)
4016                                 {
4017                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_UNDEAD, (PM_ALLOW_GROUP | p_mode));
4018                                 }
4019
4020                                 if (known && !see_t && count)
4021                                 {
4022                                     mon_fight = TRUE;
4023                                 }
4024
4025                                 break;
4026                         }
4027
4028                         /* RF6_S_DRAGON */
4029                         case 160+27:
4030                         {
4031                                 if (known)
4032                                 {
4033                                         if (see_either)
4034                                         {
4035                                                 disturb(1, 0);
4036
4037 #ifdef JP
4038 msg_format("%^s¤¬ËâË¡¤Ç¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
4039 #else
4040                                                 msg_format("%^s magically summons a dragon!", m_name);
4041 #endif
4042
4043                                         }
4044                                         else
4045                                         {
4046                                                 mon_fight = TRUE;
4047                                         }
4048                                 }
4049
4050                                 for (k = 0; k < 1; k++)
4051                                 {
4052                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_DRAGON, (PM_ALLOW_GROUP | p_mode));
4053                                 }
4054
4055                                 if (known && !see_t && count)
4056                                 {
4057                                     mon_fight = TRUE;
4058                                 }
4059
4060                                 break;
4061                         }
4062
4063                         /* RF6_S_HI_UNDEAD */
4064                         case 160+28:
4065                         {
4066                                 if (known)
4067                                 {
4068                                         if (see_either)
4069                                         {
4070                                                 disturb(1, 0);
4071
4072 #ifdef JP
4073 msg_format("%s¤¬ËâË¡¤Ç¥¢¥ó¥Ç¥Ã¥É¤ò¾¤´¤·¤¿¡£", m_name);
4074 #else
4075                                                 msg_format("%^s magically summons undead.", m_name);
4076 #endif
4077
4078                                         }
4079                                         else
4080                                         {
4081                                                 mon_fight = TRUE;
4082                                         }
4083                                 }
4084
4085                                 for (k = 0; k < s_num_6; k++)
4086                                 {
4087                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_UNDEAD, (PM_ALLOW_GROUP | p_mode | u_mode));
4088                                 }
4089
4090                                 if (known && !see_t && count)
4091                                 {
4092                                    mon_fight = TRUE;
4093                                 }
4094
4095                                 break;
4096                         }
4097
4098                         /* RF6_S_HI_DRAGON */
4099                         case 160+29:
4100                         {
4101                                 if (known)
4102                                 {
4103                                         if (see_either)
4104                                         {
4105                                                 disturb(1, 0);
4106
4107 #ifdef JP
4108 msg_format("%^s¤¬ËâË¡¤Ç¸ÅÂå¥É¥é¥´¥ó¤ò¾¤´¤·¤¿¡ª", m_name);
4109 #else
4110                                                 msg_format("%^s magically summons ancient dragons!", m_name);
4111 #endif
4112
4113                                         }
4114                                         else
4115                                         {
4116                                                 mon_fight = TRUE;
4117                                         }
4118                                 }
4119
4120                                 for (k = 0; k < s_num_4; k++)
4121                                 {
4122                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_HI_DRAGON, (PM_ALLOW_GROUP | p_mode | u_mode));
4123                                 }
4124
4125                                 if (known && !see_t && count)
4126                                 {
4127                                    mon_fight = TRUE;
4128                                 }
4129
4130                                 break;
4131                         }
4132
4133                         /* RF6_S_AMBERITES */
4134                         case 160+30:
4135                         {
4136                                 if (known)
4137                                 {
4138                                         if (see_either)
4139                                         {
4140                                                 disturb(1, 0);
4141
4142 #ifdef JP
4143 msg_format("%^s¤¬¥¢¥ó¥Ð¡¼¤Î²¦Â²¤ò¾¤´¤·¤¿¡ª", m_name);
4144 #else
4145                                                 msg_format("%^s magically summons Lords of Amber!", m_name);
4146 #endif
4147
4148                                         }
4149                                         else
4150                                         {
4151                                                 mon_fight = TRUE;
4152                                         }
4153                                 }
4154
4155                                 for (k = 0; k < s_num_4; k++)
4156                                 {
4157                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_AMBERITES, (PM_ALLOW_GROUP | p_mode | PM_ALLOW_UNIQUE));
4158                                 }
4159
4160                                 if (known && !see_t && count)
4161                                 {
4162                                    mon_fight = TRUE;
4163                                 }
4164
4165                                 break;
4166                         }
4167
4168                         /* RF6_S_UNIQUE */
4169                         case 160+31:
4170                         {
4171                                 if (known)
4172                                 {
4173                                         if (see_either)
4174                                         {
4175                                                 disturb(1, 0);
4176
4177 #ifdef JP
4178 msg_format("%^s¤¬ËâË¡¤ÇÆÃÊÌ¤Ê¶¯Å¨¤ò¾¤´¤·¤¿¡ª", m_name);
4179 #else
4180                                                 msg_format("%^s magically summons special opponents!", m_name);
4181 #endif
4182
4183                                         }
4184                                         else
4185                                         {
4186                                                 mon_fight = TRUE;
4187                                         }
4188                                 }
4189
4190                                 for (k = 0; k < s_num_4; k++)
4191                                 {
4192                                         count += summon_specific(m_idx, y, x, rlev, SUMMON_UNIQUE, (PM_ALLOW_GROUP | p_mode | PM_ALLOW_UNIQUE));
4193                                 }
4194
4195                                 if (known && !see_t && count)
4196                                 {
4197                                    mon_fight = TRUE;
4198                                 }
4199
4200                                 break;
4201                         }
4202                 }
4203
4204                 if (wake_up)
4205                 {
4206                         t_ptr->csleep = 0;
4207                 }
4208
4209                 if (fear && see_t)
4210                 {
4211 #ifdef JP
4212 msg_format("%^s¤Ï¶²ÉÝ¤·¤ÆÆ¨¤²½Ð¤·¤¿¡ª", t_name);
4213 #else
4214                         msg_format("%^s flees in terror!", t_name);
4215 #endif
4216
4217                 }
4218
4219                 if (see_m && maneable && !world_monster && !p_ptr->blind && (p_ptr->pclass == CLASS_IMITATOR))
4220                 {
4221                         if (thrown_spell != 167)
4222                         {
4223                                 if (p_ptr->mane_num == MAX_MANE)
4224                                 {
4225                                         int i;
4226                                         p_ptr->mane_num--;
4227                                         for (i = 0;i < p_ptr->mane_num-1;i++)
4228                                         {
4229                                                 p_ptr->mane_spell[i] = p_ptr->mane_spell[i+1];
4230                                                 p_ptr->mane_dam[i] = p_ptr->mane_dam[i+1];
4231                                         }
4232                                 }
4233                                 p_ptr->mane_spell[p_ptr->mane_num] = thrown_spell - 96;
4234                                 p_ptr->mane_dam[p_ptr->mane_num] = dam;
4235                                 p_ptr->mane_num++;
4236                                 new_mane = TRUE;
4237
4238                                 p_ptr->redraw |= (PR_MANE);
4239                         }
4240                 }
4241
4242                 /* Remember what the monster did, if we saw it */
4243                 if (see_m)
4244                 {
4245                         /* Inate spell */
4246                         if (thrown_spell < 32*4)
4247                         {
4248                                 r_ptr->r_flags4 |= (1L << (thrown_spell - 32*3));
4249                                 if (r_ptr->r_cast_inate < MAX_UCHAR) r_ptr->r_cast_inate++;
4250                         }
4251
4252                         /* Bolt or Ball */
4253                         else if (thrown_spell < 32*5)
4254                         {
4255                                 r_ptr->r_flags5 |= (1L << (thrown_spell - 32*4));
4256                                 if (r_ptr->r_cast_spell < MAX_UCHAR) r_ptr->r_cast_spell++;
4257                         }
4258
4259                         /* Special spell */
4260                         else if (thrown_spell < 32*6)
4261                         {
4262                                 r_ptr->r_flags6 |= (1L << (thrown_spell - 32*5));
4263                                 if (r_ptr->r_cast_spell < MAX_UCHAR) r_ptr->r_cast_spell++;
4264                         }
4265                 }
4266
4267                 /* Always take note of monsters that kill you */
4268                 if (p_ptr->is_dead && (r_ptr->r_deaths < MAX_SHORT) && !p_ptr->inside_arena)
4269                 {
4270                         r_ptr->r_deaths++;
4271                 }
4272
4273                 /* A spell was cast */
4274                 return (TRUE);
4275         }
4276
4277         /* No enemy found */
4278         return (FALSE);
4279 }