src/monster-process.c

   1 /*!
   2  * @file monster-process.c
   3  * @brief モンスターの特殊技能と移動処理/ Monster spells and movement
   4  * @date 2014/01/17
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
   7  * This software may be copied and distributed for educational, research,\n
   8  * and not for profit purposes provided that this copyright and statement\n
   9  * are included in all such copies.  Other copyrights may also apply.\n
  10  * 2014 Deskull rearranged comment for Doxygen.\n
  11  * @details
  12  * This file has several additions to it by Keldon Jones (keldon@umr.edu)
  13  * to improve the general quality of the AI (version 0.1.1).
  14  */
  15
  16 #include "angband.h"
  17 #include "util.h"
  18
  19 #include "cmd-dump.h"
  20 #include "cmd-pet.h"
  21 #include "melee.h"
  22 #include "spells.h"
  23 #include "spells-summon.h"
  24 #include "quest.h"
  25 #include "avatar.h"
  26 #include "realm-hex.h"
  27 #include "object-flavor.h"
  28 #include "object-hook.h"
  29 #include "feature.h"
  30 #include "grid.h"
  31 #include "player-move.h"
  32 #include "monster-status.h"
  33 #include "monster-spell.h"
  34 #include "monster-process.h"
  35 #include "monsterrace-hook.h"
  36 #include "dungeon.h"
  37 #include "floor.h"
  38 #include "files.h"
  39
  40
  41 /*!
  42  * @brief モンスターが敵に接近するための方向を決める /
  43  * Calculate the direction to the next enemy
  44  * @param m_idx モンスターの参照ID
  45  * @param mm 移動するべき方角IDを返す参照ポインタ
  46  * @return 方向が確定した場合TRUE、接近する敵がそもそもいない場合FALSEを返す
  47  */
  48 static bool get_enemy_dir(MONSTER_IDX m_idx, int *mm)
  49 {
  50         int i;
  51         POSITION x = 0, y = 0;
  52         MONSTER_IDX t_idx;
  53         int start;
  54         int plus = 1;
  55
  56         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
  57         monster_race *r_ptr = &r_info[m_ptr->r_idx];
  58         monster_type *t_ptr;
  59
  60         if (riding_t_m_idx && player_bold(m_ptr->fy, m_ptr->fx))
  61         {
  62                 y = current_floor_ptr->m_list[riding_t_m_idx].fy;
  63                 x = current_floor_ptr->m_list[riding_t_m_idx].fx;
  64         }
  65         else if (is_pet(m_ptr) && pet_t_m_idx)
  66         {
  67                 y = current_floor_ptr->m_list[pet_t_m_idx].fy;
  68                 x = current_floor_ptr->m_list[pet_t_m_idx].fx;
  69         }
  70         else
  71         {
  72                 if (p_ptr->inside_battle)
  73                 {
  74                         start = randint1(current_floor_ptr->m_max-1)+current_floor_ptr->m_max;
  75                         if(randint0(2)) plus = -1;
  76                 }
  77                 else start = current_floor_ptr->m_max + 1;
  78
  79                 /* Scan thru all monsters */
  80                 for (i = start; ((i < start + current_floor_ptr->m_max) && (i > start - current_floor_ptr->m_max)); i+=plus)
  81                 {
  82                         MONSTER_IDX dummy = (i % current_floor_ptr->m_max);
  83
  84                         if (!dummy) continue;
  85
  86                         t_idx = dummy;
  87                         t_ptr = &current_floor_ptr->m_list[t_idx];
  88
  89                         /* The monster itself isn't a target */
  90                         if (t_ptr == m_ptr) continue;
  91
  92                         if (!monster_is_valid(t_ptr)) continue;
  93
  94                         if (is_pet(m_ptr))
  95                         {
  96                                 /* Hack -- only fight away from player */
  97                                 if (p_ptr->pet_follow_distance < 0)
  98                                 {
  99                                         /* No fighting near player */
 100                                         if (t_ptr->cdis <= (0 - p_ptr->pet_follow_distance))
 101                                         {
 102                                                 continue;
 103                                         }
 104                                 }
 105                                 /* Hack -- no fighting away from player */
 106                                 else if ((m_ptr->cdis < t_ptr->cdis) && (t_ptr->cdis > p_ptr->pet_follow_distance))
 107                                 {
 108                                         continue;
 109                                 }
 110
 111                                 if (r_ptr->aaf < t_ptr->cdis) continue;
 112                         }
 113
 114                         /* Monster must be 'an enemy' */
 115                         if (!are_enemies(m_ptr, t_ptr)) continue;
 116
 117                         /* Monster must be projectable if we can't pass through walls */
 118                         if (((r_ptr->flags2 & RF2_PASS_WALL) && ((m_idx != p_ptr->riding) || p_ptr->pass_wall)) ||
 119                             ((r_ptr->flags2 & RF2_KILL_WALL) && (m_idx != p_ptr->riding)))
 120                         {
 121                                 if (!in_disintegration_range(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx)) continue;
 122                         }
 123                         else
 124                         {
 125                                 if (!projectable(m_ptr->fy, m_ptr->fx, t_ptr->fy, t_ptr->fx)) continue;
 126                         }
 127
 128                         /* OK -- we've got a target */
 129                         y = t_ptr->fy;
 130                         x = t_ptr->fx;
 131
 132                         break;
 133                 }
 134                 if (!x && !y) return FALSE;
 135         }
 136
 137         /* Extract the direction */
 138         x -= m_ptr->fx;
 139         y -= m_ptr->fy;
 140
 141         /* North */
 142         if ((y < 0) && (x == 0))
 143         {
 144                 mm[0] = 8;
 145                 mm[1] = 7;
 146                 mm[2] = 9;
 147         }
 148         /* South */
 149         else if ((y > 0) && (x == 0))
 150         {
 151                 mm[0] = 2;
 152                 mm[1] = 1;
 153                 mm[2] = 3;
 154         }
 155         /* East */
 156         else if ((x > 0) && (y == 0))
 157         {
 158                 mm[0] = 6;
 159                 mm[1] = 9;
 160                 mm[2] = 3;
 161         }
 162         /* West */
 163         else if ((x < 0) && (y == 0))
 164         {
 165                 mm[0] = 4;
 166                 mm[1] = 7;
 167                 mm[2] = 1;
 168         }
 169         /* North-West */
 170         else if ((y < 0) && (x < 0))
 171         {
 172                 mm[0] = 7;
 173                 mm[1] = 4;
 174                 mm[2] = 8;
 175         }
 176         /* North-East */
 177         else if ((y < 0) && (x > 0))
 178         {
 179                 mm[0] = 9;
 180                 mm[1] = 6;
 181                 mm[2] = 8;
 182         }
 183         /* South-West */
 184         else if ((y > 0) && (x < 0))
 185         {
 186                 mm[0] = 1;
 187                 mm[1] = 4;
 188                 mm[2] = 2;
 189         }
 190         /* South-East */
 191         else if ((y > 0) && (x > 0))
 192         {
 193                 mm[0] = 3;
 194                 mm[1] = 6;
 195                 mm[2] = 2;
 196         }
 197
 198         /* Found a monster */
 199         return TRUE;
 200 }
 201
 202 /*!
 203  * @brief モンスターがプレイヤーから逃走するかどうかを返す /
 204  * Returns whether a given monster will try to run from the player.
 205  * @param m_idx 逃走するモンスターの参照ID
 206  * @return モンスターがプレイヤーから逃走するならばTRUEを返す。
 207  * @details
 208  * Monsters will attempt to avoid very powerful players.  See below.\n
 209  *\n
 210  * Because this function is called so often, little details are important\n
 211  * for efficiency.  Like not using "mod" or "div" when possible.  And\n
 212  * attempting to check the conditions in an optimal order.  Note that\n
 213  * "(x << 2) == (x * 4)" if "x" has enough bits to hold the result.\n
 214  *\n
 215  * Note that this function is responsible for about one to five percent\n
 216  * of the processor use in normal conditions...\n
 217  */
 218 static bool mon_will_run(MONSTER_IDX m_idx)
 219 {
 220         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
 221
 222 #ifdef ALLOW_TERROR
 223
 224         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 225
 226         PLAYER_LEVEL p_lev;
 227         DEPTH m_lev;
 228         HIT_POINT p_chp, p_mhp;
 229         HIT_POINT m_chp, m_mhp;
 230         u32b p_val, m_val;
 231
 232 #endif
 233
 234         /* Friends can be commanded to avoid the player */
 235         if (is_pet(m_ptr))
 236         {
 237                 /* Are we trying to avoid the player? */
 238                 return ((p_ptr->pet_follow_distance < 0) &&
 239                                   (m_ptr->cdis <= (0 - p_ptr->pet_follow_distance)));
 240         }
 241
 242         /* Keep monsters from running too far away */
 243         if (m_ptr->cdis > MAX_SIGHT + 5) return (FALSE);
 244
 245         /* All "afraid" monsters will run away */
 246         if (MON_MONFEAR(m_ptr)) return (TRUE);
 247
 248 #ifdef ALLOW_TERROR
 249
 250         /* Nearby monsters will not become terrified */
 251         if (m_ptr->cdis <= 5) return (FALSE);
 252
 253         /* Examine player power (level) */
 254         p_lev = p_ptr->lev;
 255
 256         /* Examine monster power (level plus morale) */
 257         m_lev = r_ptr->level + (m_idx & 0x08) + 25;
 258
 259         /* Optimize extreme cases below */
 260         if (m_lev > p_lev + 4) return (FALSE);
 261         if (m_lev + 4 <= p_lev) return (TRUE);
 262
 263         /* Examine player health */
 264         p_chp = p_ptr->chp;
 265         p_mhp = p_ptr->mhp;
 266
 267         /* Examine monster health */
 268         m_chp = m_ptr->hp;
 269         m_mhp = m_ptr->maxhp;
 270
 271         /* Prepare to optimize the calculation */
 272         p_val = (p_lev * p_mhp) + (p_chp << 2); /* div p_mhp */
 273         m_val = (m_lev * m_mhp) + (m_chp << 2); /* div m_mhp */
 274
 275         /* Strong players scare strong monsters */
 276         if (p_val * m_mhp > m_val * p_mhp) return (TRUE);
 277
 278 #endif
 279
 280         /* Assume no terror */
 281         return (FALSE);
 282 }
 283
 284
 285 /*!
 286  * @brief モンスターがプレイヤーに向けて遠距離攻撃を行うことが可能なマスを走査する /
 287  * Search spell castable grid
 288  * @param m_idx モンスターの参照ID
 289  * @param yp 適したマスのY座標を返す参照ポインタ
 290  * @param xp 適したマスのX座標を返す参照ポインタ
 291  * @return 有効なマスがあった場合TRUEを返す
 292  */
 293 static bool get_moves_aux2(MONSTER_IDX m_idx, POSITION *yp, POSITION *xp)
 294 {
 295         int i, best = 999;
 296         POSITION y, x, y1, x1;
 297
 298         grid_type *g_ptr;
 299         bool can_open_door = FALSE;
 300         int now_cost;
 301
 302         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
 303         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 304
 305         /* Monster location */
 306         y1 = m_ptr->fy;
 307         x1 = m_ptr->fx;
 308
 309         /* Monster can already cast spell to player */
 310         if (projectable(y1, x1, p_ptr->y, p_ptr->x)) return (FALSE);
 311
 312         /* Set current grid cost */
 313         now_cost = current_floor_ptr->grid_array[y1][x1].cost;
 314         if (now_cost == 0) now_cost = 999;
 315
 316         /* Can monster bash or open doors? */
 317         if (r_ptr->flags2 & (RF2_BASH_DOOR | RF2_OPEN_DOOR))
 318         {
 319                 can_open_door = TRUE;
 320         }
 321
 322         /* Check nearby grids, diagonals first */
 323         for (i = 7; i >= 0; i--)
 324         {
 325                 int cost;
 326
 327                 y = y1 + ddy_ddd[i];
 328                 x = x1 + ddx_ddd[i];
 329
 330                 /* Ignore locations off of edge */
 331                 if (!in_bounds2(y, x)) continue;
 332
 333                 /* Simply move to player */
 334                 if (player_bold(y, x)) return (FALSE);
 335
 336                 g_ptr = &current_floor_ptr->grid_array[y][x];
 337
 338                 cost = g_ptr->cost;
 339
 340                 /* Monster cannot kill or pass walls */
 341                 if (!(((r_ptr->flags2 & RF2_PASS_WALL) && ((m_idx != p_ptr->riding) || p_ptr->pass_wall)) || ((r_ptr->flags2 & RF2_KILL_WALL) && (m_idx != p_ptr->riding))))
 342                 {
 343                         if (cost == 0) continue;
 344                         if (!can_open_door && is_closed_door(g_ptr->feat)) continue;
 345                 }
 346
 347                 /* Hack -- for kill or pass wall monster.. */
 348                 if (cost == 0) cost = 998;
 349
 350                 if (now_cost < cost) continue;
 351
 352                 if (!projectable(y, x, p_ptr->y, p_ptr->x)) continue;
 353
 354                 /* Accept louder sounds */
 355                 if (best < cost) continue;
 356                 best = cost;
 357
 358                 (*yp) = y1 + ddy_ddd[i];
 359                 (*xp) = x1 + ddx_ddd[i];
 360         }
 361
 362         /* No legal move (?) */
 363         if (best == 999) return (FALSE);
 364
 365         /* Success */
 366         return (TRUE);
 367 }
 368
 369
 370 /*!
 371  * @brief モンスターがプレイヤーに向けて接近することが可能なマスを走査する /
 372  * Choose the "best" direction for "flowing"
 373  * @param m_idx モンスターの参照ID
 374  * @param yp 移動先のマスのY座標を返す参照ポインタ
 375  * @param xp 移動先のマスのX座標を返す参照ポインタ
 376  * @param no_flow モンスターにFLOWフラグが経っていない状態でTRUE
 377  * @return 有効なマスがあった場合TRUEを返す
 378  * @details
 379  * Note that ghosts and rock-eaters are never allowed to "flow",\n
 380  * since they should move directly towards the player.\n
 381  *\n
 382  * Prefer "non-diagonal" directions, but twiddle them a little\n
 383  * to angle slightly towards the player's actual location.\n
 384  *\n
 385  * Allow very perceptive monsters to track old "spoor" left by\n
 386  * previous locations occupied by the player.  This will tend\n
 387  * to have monsters end up either near the player or on a grid\n
 388  * recently occupied by the player (and left via "teleport").\n
 389  *\n
 390  * Note that if "smell" is turned on, all monsters get vicious.\n
 391  *\n
 392  * Also note that teleporting away from a location will cause\n
 393  * the monsters who were chasing you to converge on that location\n
 394  * as long as you are still near enough to "annoy" them without\n
 395  * being close enough to chase directly.  I have no idea what will\n
 396  * happen if you combine "smell" with low "aaf" values.\n
 397  */
 398 static bool get_moves_aux(MONSTER_IDX m_idx, POSITION *yp, POSITION *xp, bool no_flow)
 399 {
 400         int i, best;
 401         POSITION y, x, y1, x1;
 402
 403         grid_type *g_ptr;
 404         bool use_scent = FALSE;
 405
 406         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
 407         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 408
 409         /* Can monster cast attack spell? */
 410         if (r_ptr->flags4 & (RF4_ATTACK_MASK) ||
 411             r_ptr->a_ability_flags1 & (RF5_ATTACK_MASK) ||
 412             r_ptr->a_ability_flags2 & (RF6_ATTACK_MASK))
 413         {
 414                 /* Can move spell castable grid? */
 415                 if (get_moves_aux2(m_idx, yp, xp)) return (TRUE);
 416         }
 417
 418         /* Monster can't flow */
 419         if (no_flow) return (FALSE);
 420
 421         /* Monster can go through rocks */
 422         if ((r_ptr->flags2 & RF2_PASS_WALL) && ((m_idx != p_ptr->riding) || p_ptr->pass_wall)) return (FALSE);
 423         if ((r_ptr->flags2 & RF2_KILL_WALL) && (m_idx != p_ptr->riding)) return (FALSE);
 424
 425         /* Monster location */
 426         y1 = m_ptr->fy;
 427         x1 = m_ptr->fx;
 428
 429         /* Hack -- Player can see us, run towards him */
 430         if (player_has_los_bold(y1, x1) && projectable(p_ptr->y, p_ptr->x, y1, x1)) return (FALSE);
 431
 432         /* Monster grid */
 433         g_ptr = &current_floor_ptr->grid_array[y1][x1];
 434
 435         /* If we can hear noises, advance towards them */
 436         if (g_ptr->cost)
 437         {
 438                 best = 999;
 439         }
 440
 441         /* Otherwise, try to follow a scent trail */
 442         else if (g_ptr->when)
 443         {
 444                 /* Too old smell */
 445                 if (current_floor_ptr->grid_array[p_ptr->y][p_ptr->x].when - g_ptr->when > 127) return (FALSE);
 446
 447                 use_scent = TRUE;
 448                 best = 0;
 449         }
 450
 451         /* Otherwise, advance blindly */
 452         else
 453         {
 454                 return (FALSE);
 455         }
 456
 457         /* Check nearby grids, diagonals first */
 458         for (i = 7; i >= 0; i--)
 459         {
 460                 y = y1 + ddy_ddd[i];
 461                 x = x1 + ddx_ddd[i];
 462
 463                 /* Ignore locations off of edge */
 464                 if (!in_bounds2(y, x)) continue;
 465
 466                 g_ptr = &current_floor_ptr->grid_array[y][x];
 467
 468                 /* We're following a scent trail */
 469                 if (use_scent)
 470                 {
 471                         int when = g_ptr->when;
 472
 473                         /* Accept younger scent */
 474                         if (best > when) continue;
 475                         best = when;
 476                 }
 477
 478                 /* We're using sound */
 479                 else
 480                 {
 481                         int cost;
 482
 483                         if (r_ptr->flags2 & (RF2_BASH_DOOR | RF2_OPEN_DOOR))
 484                                 cost = g_ptr->dist;
 485                         else cost = g_ptr->cost;
 486
 487                         /* Accept louder sounds */
 488                         if ((cost == 0) || (best < cost)) continue;
 489                         best = cost;
 490                 }
 491
 492                 /* Hack -- Save the "twiddled" location */
 493                 (*yp) = p_ptr->y + 16 * ddy_ddd[i];
 494                 (*xp) = p_ptr->x + 16 * ddx_ddd[i];
 495         }
 496
 497         /* No legal move (?) */
 498         if (best == 999 || best == 0) return (FALSE);
 499
 500         /* Success */
 501         return (TRUE);
 502 }
 503
 504
 505 /*!
 506  * @brief モンスターがプレイヤーから逃走することが可能なマスを走査する /
 507  * Provide a location to flee to, but give the player a wide berth.
 508  * @param m_idx モンスターの参照ID
 509  * @param yp 移動先のマスのY座標を返す参照ポインタ
 510  * @param xp 移動先のマスのX座標を返す参照ポインタ
 511  * @return 有効なマスがあった場合TRUEを返す
 512  * @details
 513  * A monster may wish to flee to a location that is behind the player,\n
 514  * but instead of heading directly for it, the monster should "swerve"\n
 515  * around the player so that he has a smaller chance of getting hit.\n
 516  */
 517 static bool get_fear_moves_aux(MONSTER_IDX m_idx, POSITION *yp, POSITION *xp)
 518 {
 519         POSITION y, x, y1, x1, fy, fx, gy = 0, gx = 0;
 520         int score = -1;
 521         int i;
 522
 523         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
 524
 525         /* Monster location */
 526         fy = m_ptr->fy;
 527         fx = m_ptr->fx;
 528
 529         /* Desired destination */
 530         y1 = fy - (*yp);
 531         x1 = fx - (*xp);
 532
 533         /* Check nearby grids, diagonals first */
 534         for (i = 7; i >= 0; i--)
 535         {
 536                 POSITION dis, s;
 537
 538                 y = fy + ddy_ddd[i];
 539                 x = fx + ddx_ddd[i];
 540
 541                 /* Ignore locations off of edge */
 542                 if (!in_bounds2(y, x)) continue;
 543
 544                 /* Don't move toward player */
 545                 /* if (current_floor_ptr->grid_array[y][x].dist < 3) continue; */ /* Hmm.. Need it? */
 546
 547                 /* Calculate distance of this grid from our destination */
 548                 dis = distance(y, x, y1, x1);
 549
 550                 /* Score this grid */
 551                 s = 5000 / (dis + 3) - 500 / (current_floor_ptr->grid_array[y][x].dist + 1);
 552
 553                 /* No negative scores */
 554                 if (s < 0) s = 0;
 555
 556                 /* Ignore lower scores */
 557                 if (s < score) continue;
 558
 559                 /* Save the score and time */
 560                 score = s;
 561
 562                 /* Save the location */
 563                 gy = y;
 564                 gx = x;
 565         }
 566
 567         /* No legal move (?) */
 568         if (score == -1) return (FALSE);
 569
 570         /* Find deltas */
 571         (*yp) = fy - gy;
 572         (*xp) = fx - gx;
 573
 574         /* Success */
 575         return (TRUE);
 576 }
 577
 578 /*
 579  * Hack -- Precompute a bunch of calls to distance() in find_safety() and
 580  * find_hiding().
 581  *
 582  * The pair of arrays dist_offsets_y[n] and dist_offsets_x[n] contain the
 583  * offsets of all the locations with a distance of n from a central point,
 584  * with an offset of (0,0) indicating no more offsets at this distance.
 585  *
 586  * This is, of course, fairly unreadable, but it eliminates multiple loops
 587  * from the previous version.
 588  *
 589  * It is probably better to replace these arrays with code to compute
 590  * the relevant arrays, even if the storage is pre-allocated in hard
 591  * coded sizes.  At the very least, code should be included which is
 592  * able to generate and dump these arrays (ala "los()").
 593  *
 594  * Also, the storage needs could be halved by using bytes.
 595  *
 596  * These arrays could be combined into two big arrays, using sub-arrays
 597  * to hold the offsets and lengths of each portion of the sub-arrays, and
 598  * this could perhaps also be used somehow in the "look" code.
 599  */
 600
 601
 602 static POSITION d_off_y_0[] = { 0 };
 603 static POSITION d_off_x_0[] = { 0 };
 604
 605 static POSITION d_off_y_1[] = { -1, -1, -1, 0, 0, 1, 1, 1, 0 };
 606 static POSITION d_off_x_1[] = { -1, 0, 1, -1, 1, -1, 0, 1, 0 };
 607
 608 static POSITION d_off_y_2[] = { -1, -1, -2, -2, -2, 0, 0, 1, 1, 2, 2, 2, 0 };
 609 static POSITION d_off_x_2[] = { -2, 2, -1, 0, 1, -2, 2, -2, 2, -1, 0, 1, 0 };
 610
 611 static POSITION d_off_y_3[] = { -1, -1, -2, -2, -3, -3, -3, 0, 0, 1, 1, 2, 2, 3, 3, 3, 0 };
 612 static POSITION d_off_x_3[] = { -3, 3, -2, 2, -1, 0, 1, -3, 3, -3, 3, -2, 2, -1, 0, 1, 0 };
 613
 614 static POSITION d_off_y_4[] = { -1, -1, -2, -2, -3, -3, -3, -3, -4, -4, -4, 0, 0, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 0 };
 615 static POSITION d_off_x_4[] = { -4, 4, -3, 3, -2, -3, 2, 3, -1, 0, 1, -4, 4, -4, 4, -3, 3, -2, -3, 2, 3, -1, 0, 1, 0 };
 616
 617
 618 static POSITION d_off_y_5[] =
 619 { -1, -1, -2, -2, -3, -3, -4, -4, -4, -4, -5, -5,
 620   -5, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5,
 621   5, 0 };
 622
 623 static POSITION d_off_x_5[] =
 624 { -5, 5, -4, 4, -4, 4, -2, -3, 2, 3, -1, 0, 1,
 625   -5, 5, -5, 5, -4, 4, -4, 4, -2, -3, 2, 3, -1,
 626   0, 1, 0 };
 627
 628
 629 static POSITION d_off_y_6[] =
 630 { -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -5, -5,
 631   -6, -6, -6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5,
 632   5, 5, 6, 6, 6, 0 };
 633
 634 static POSITION d_off_x_6[] =
 635 { -6, 6, -5, 5, -5, 5, -4, 4, -2, -3, 2, 3, -1,
 636   0, 1, -6, 6, -6, 6, -5, 5, -5, 5, -4, 4, -2,
 637   -3, 2, 3, -1, 0, 1, 0 };
 638
 639
 640 static POSITION d_off_y_7[] =
 641 { -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -5, -5,
 642   -6, -6, -6, -6, -7, -7, -7, 0, 0, 1, 1, 2, 2, 3,
 643   3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 0 };
 644
 645 static POSITION d_off_x_7[] =
 646 { -7, 7, -6, 6, -6, 6, -5, 5, -4, -5, 4, 5, -2,
 647   -3, 2, 3, -1, 0, 1, -7, 7, -7, 7, -6, 6, -6,
 648   6, -5, 5, -4, -5, 4, 5, -2, -3, 2, 3, -1, 0,
 649   1, 0 };
 650
 651
 652 static POSITION d_off_y_8[] =
 653 { -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6,
 654   -6, -6, -7, -7, -7, -7, -8, -8, -8, 0, 0, 1, 1,
 655   2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
 656   8, 8, 8, 0 };
 657
 658 static POSITION d_off_x_8[] =
 659 { -8, 8, -7, 7, -7, 7, -6, 6, -6, 6, -4, -5, 4,
 660   5, -2, -3, 2, 3, -1, 0, 1, -8, 8, -8, 8, -7,
 661   7, -7, 7, -6, 6, -6, 6, -4, -5, 4, 5, -2, -3,
 662   2, 3, -1, 0, 1, 0 };
 663
 664
 665 static POSITION d_off_y_9[] =
 666 { -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6,
 667   -7, -7, -7, -7, -8, -8, -8, -8, -9, -9, -9, 0,
 668   0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 7,
 669   7, 8, 8, 8, 8, 9, 9, 9, 0 };
 670
 671 static POSITION d_off_x_9[] =
 672 { -9, 9, -8, 8, -8, 8, -7, 7, -7, 7, -6, 6, -4,
 673   -5, 4, 5, -2, -3, 2, 3, -1, 0, 1, -9, 9, -9,
 674   9, -8, 8, -8, 8, -7, 7, -7, 7, -6, 6, -4, -5,
 675   4, 5, -2, -3, 2, 3, -1, 0, 1, 0 };
 676
 677
 678 static POSITION *dist_offsets_y[10] =
 679 {
 680         d_off_y_0, d_off_y_1, d_off_y_2, d_off_y_3, d_off_y_4,
 681         d_off_y_5, d_off_y_6, d_off_y_7, d_off_y_8, d_off_y_9
 682 };
 683
 684 static POSITION *dist_offsets_x[10] =
 685 {
 686         d_off_x_0, d_off_x_1, d_off_x_2, d_off_x_3, d_off_x_4,
 687         d_off_x_5, d_off_x_6, d_off_x_7, d_off_x_8, d_off_x_9
 688 };
 689
 690 /*!
 691  * @brief モンスターが逃げ込める安全な地点を返す /
 692  * Choose a "safe" location near a monster for it to run toward.
 693  * @param m_idx モンスターの参照ID
 694  * @param yp 移動先のマスのY座標を返す参照ポインタ
 695  * @param xp 移動先のマスのX座標を返す参照ポインタ
 696  * @return 有効なマスがあった場合TRUEを返す
 697  * @details
 698  * A location is "safe" if it can be reached quickly and the player\n
 699  * is not able to fire into it (it isn't a "clean shot").  So, this will\n
 700  * cause monsters to "duck" behind walls.  Hopefully, monsters will also\n
 701  * try to run towards corridor openings if they are in a room.\n
 702  *\n
 703  * This function may take lots of CPU time if lots of monsters are\n
 704  * fleeing.\n
 705  *\n
 706  * Return TRUE if a safe location is available.\n
 707  */
 708 static bool find_safety(MONSTER_IDX m_idx, POSITION *yp, POSITION *xp)
 709 {
 710         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
 711
 712         POSITION fy = m_ptr->fy;
 713         POSITION fx = m_ptr->fx;
 714
 715         POSITION y, x, dy, dx, d, dis, i;
 716         POSITION gy = 0, gx = 0, gdis = 0;
 717
 718         POSITION *y_offsets;
 719         POSITION *x_offsets;
 720
 721         grid_type *g_ptr;
 722
 723         /* Start with adjacent locations, spread further */
 724         for (d = 1; d < 10; d++)
 725         {
 726                 /* Get the lists of points with a distance d from (fx, fy) */
 727                 y_offsets = dist_offsets_y[d];
 728                 x_offsets = dist_offsets_x[d];
 729
 730                 /* Check the locations */
 731                 for (i = 0, dx = x_offsets[0], dy = y_offsets[0];
 732                      dx != 0 || dy != 0;
 733                      i++, dx = x_offsets[i], dy = y_offsets[i])
 734                 {
 735                         y = fy + dy;
 736                         x = fx + dx;
 737
 738                         /* Skip illegal locations */
 739                         if (!in_bounds(y, x)) continue;
 740
 741                         g_ptr = &current_floor_ptr->grid_array[y][x];
 742
 743                         /* Skip locations in a wall */
 744                         if (!monster_can_cross_terrain(g_ptr->feat, &r_info[m_ptr->r_idx], (m_idx == p_ptr->riding) ? CEM_RIDING : 0)) continue;
 745
 746                         /* Check for "availability" (if monsters can flow) */
 747                         if (!(m_ptr->mflag2 & MFLAG2_NOFLOW))
 748                         {
 749                                 /* Ignore grids very far from the player */
 750                                 if (g_ptr->dist == 0) continue;
 751
 752                                 /* Ignore too-distant grids */
 753                                 if (g_ptr->dist > current_floor_ptr->grid_array[fy][fx].dist + 2 * d) continue;
 754                         }
 755
 756                         /* Check for absence of shot (more or less) */
 757                         if (!projectable(p_ptr->y, p_ptr->x, y, x))
 758                         {
 759                                 /* Calculate distance from player */
 760                                 dis = distance(y, x, p_ptr->y, p_ptr->x);
 761
 762                                 /* Remember if further than previous */
 763                                 if (dis > gdis)
 764                                 {
 765                                         gy = y;
 766                                         gx = x;
 767                                         gdis = dis;
 768                                 }
 769                         }
 770                 }
 771
 772                 /* Check for success */
 773                 if (gdis > 0)
 774                 {
 775                         /* Good location */
 776                         (*yp) = fy - gy;
 777                         (*xp) = fx - gx;
 778
 779                         /* Found safe place */
 780                         return (TRUE);
 781                 }
 782         }
 783
 784         /* No safe place */
 785         return (FALSE);
 786 }
 787
 788
 789 /*!
 790  * @brief モンスターが隠れ潜める地点を返す /
 791  * Choose a good hiding place near a monster for it to run toward.
 792  * @param m_idx モンスターの参照ID
 793  * @param yp 移動先のマスのY座標を返す参照ポインタ
 794  * @param xp 移動先のマスのX座標を返す参照ポインタ
 795  * @return 有効なマスがあった場合TRUEを返す
 796  * @details
 797  * Pack monsters will use this to "ambush" the player and lure him out\n
 798  * of corridors into open space so they can swarm him.\n
 799  *\n
 800  * Return TRUE if a good location is available.\n
 801  */
 802 static bool find_hiding(MONSTER_IDX m_idx, POSITION *yp, POSITION *xp)
 803 {
 804         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
 805         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 806
 807         POSITION fy = m_ptr->fy;
 808         POSITION fx = m_ptr->fx;
 809
 810         POSITION y, x, dy, dx, d, dis, i;
 811         POSITION gy = 0, gx = 0, gdis = 999;
 812
 813         POSITION *y_offsets, *x_offsets;
 814
 815         /* Start with adjacent locations, spread further */
 816         for (d = 1; d < 10; d++)
 817         {
 818                 /* Get the lists of points with a distance d from (fx, fy) */
 819                 y_offsets = dist_offsets_y[d];
 820                 x_offsets = dist_offsets_x[d];
 821
 822                 /* Check the locations */
 823                 for (i = 0, dx = x_offsets[0], dy = y_offsets[0];
 824                      dx != 0 || dy != 0;
 825                      i++, dx = x_offsets[i], dy = y_offsets[i])
 826                 {
 827                         y = fy + dy;
 828                         x = fx + dx;
 829
 830                         /* Skip illegal locations */
 831                         if (!in_bounds(y, x)) continue;
 832
 833                         /* Skip occupied locations */
 834                         if (!monster_can_enter(y, x, r_ptr, 0)) continue;
 835
 836                         /* Check for hidden, available grid */
 837                         if (!projectable(p_ptr->y, p_ptr->x, y, x) && clean_shot(fy, fx, y, x, FALSE))
 838                         {
 839                                 /* Calculate distance from player */
 840                                 dis = distance(y, x, p_ptr->y, p_ptr->x);
 841
 842                                 /* Remember if closer than previous */
 843                                 if (dis < gdis && dis >= 2)
 844                                 {
 845                                         gy = y;
 846                                         gx = x;
 847                                         gdis = dis;
 848                                 }
 849                         }
 850                 }
 851
 852                 /* Check for success */
 853                 if (gdis < 999)
 854                 {
 855                         /* Good location */
 856                         (*yp) = fy - gy;
 857                         (*xp) = fx - gx;
 858
 859                         /* Found good place */
 860                         return (TRUE);
 861                 }
 862         }
 863
 864         /* No good place */
 865         return (FALSE);
 866 }
 867
 868
 869 /*!
 870  * @brief モンスターの移動方向を返す /
 871  * Choose "logical" directions for monster movement
 872  * @param m_idx モンスターの参照ID
 873  * @param mm 移動方向を返す方向IDの参照ポインタ
 874  * @return 有効方向があった場合TRUEを返す
 875  */
 876 static bool get_moves(MONSTER_IDX m_idx, DIRECTION *mm)
 877 {
 878         monster_type *m_ptr = &current_floor_ptr->m_list[m_idx];
 879         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 880         POSITION     y = 0, ay, x = 0, ax;
 881         int          move_val = 0;
 882         POSITION     y2 = p_ptr->y;
 883         POSITION     x2 = p_ptr->x;
 884         bool         done = FALSE;
 885         bool         will_run = mon_will_run(m_idx);
 886         grid_type    *g_ptr;
 887         bool         no_flow = ((m_ptr->mflag2 & MFLAG2_NOFLOW) && (current_floor_ptr->grid_array[m_ptr->fy][m_ptr->fx].cost > 2));
 888         bool         can_pass_wall = ((r_ptr->flags2 & RF2_PASS_WALL) && ((m_idx != p_ptr->riding) || p_ptr->pass_wall));
 889
 890         /* Counter attack to an enemy monster */
 891         if (!will_run && m_ptr->target_y)
 892         {
 893                 int t_m_idx = current_floor_ptr->grid_array[m_ptr->target_y][m_ptr->target_x].m_idx;
 894
 895                 /* The monster must be an enemy, and in LOS */
 896                 if (t_m_idx &&
 897                     are_enemies(m_ptr, &current_floor_ptr->m_list[t_m_idx]) &&
 898                     los(m_ptr->fy, m_ptr->fx, m_ptr->target_y, m_ptr->target_x) &&
 899                     projectable(m_ptr->fy, m_ptr->fx, m_ptr->target_y, m_ptr->target_x))
 900                 {
 901                         /* Extract the "pseudo-direction" */
 902                         y = m_ptr->fy - m_ptr->target_y;
 903                         x = m_ptr->fx - m_ptr->target_x;
 904                         done = TRUE;
 905                 }
 906         }
 907
 908         if (!done && !will_run && is_hostile(m_ptr) &&
 909             (r_ptr->flags1 & RF1_FRIENDS) &&
 910             ((los(m_ptr->fy, m_ptr->fx, p_ptr->y, p_ptr->x) && projectable(m_ptr->fy, m_ptr->fx, p_ptr->y, p_ptr->x)) ||
 911             (current_floor_ptr->grid_array[m_ptr->fy][m_ptr->fx].dist < MAX_SIGHT / 2)))
 912         {
 913         /*
 914          * Animal packs try to get the player out of corridors
 915          * (...unless they can move through walls -- TY)
 916          */
 917                 if ((r_ptr->flags3 & RF3_ANIMAL) && !can_pass_wall &&
 918                          !(r_ptr->flags2 & RF2_KILL_WALL))
 919                 {
 920                         int i, room = 0;
 921
 922                         /* Count room grids next to player */
 923                         for (i = 0; i < 8; i++)
 924                         {
 925                                 int xx = p_ptr->x + ddx_ddd[i];
 926                                 int yy = p_ptr->y + ddy_ddd[i];
 927
 928                                 if (!in_bounds2(yy, xx)) continue;
 929
 930                                 g_ptr = &current_floor_ptr->grid_array[yy][xx];
 931
 932                                 /* Check grid */
 933                                 if (monster_can_cross_terrain(g_ptr->feat, r_ptr, 0))
 934                                 {
 935                                         /* One more room grid */
 936                                         room++;
 937                                 }
 938                         }
 939                         if (current_floor_ptr->grid_array[p_ptr->y][p_ptr->x].info & CAVE_ROOM) room -= 2;
 940                         if (!r_ptr->flags4 && !r_ptr->a_ability_flags1 && !r_ptr->a_ability_flags2) room -= 2;
 941
 942                         /* Not in a room and strong player */
 943                         if (room < (8 * (p_ptr->chp + p_ptr->csp)) /
 944                             (p_ptr->mhp + p_ptr->msp))
 945                         {
 946                                 /* Find hiding place */
 947                                 if (find_hiding(m_idx, &y, &x)) done = TRUE;
 948                         }
 949                 }
 950
 951                 /* Monster groups try to surround the player */
 952                 if (!done && (current_floor_ptr->grid_array[m_ptr->fy][m_ptr->fx].dist < 3))
 953                 {
 954                         int i;
 955
 956                         /* Find an empty square near the player to fill */
 957                         for (i = 0; i < 8; i++)
 958                         {
 959                                 /* Pick squares near player (semi-randomly) */
 960                                 y2 = p_ptr->y + ddy_ddd[(m_idx + i) & 7];
 961                                 x2 = p_ptr->x + ddx_ddd[(m_idx + i) & 7];
 962
 963                                 /* Already there? */
 964                                 if ((m_ptr->fy == y2) && (m_ptr->fx == x2))
 965                                 {
 966                                         /* Attack the player */
 967                                         y2 = p_ptr->y;
 968                                         x2 = p_ptr->x;
 969
 970                                         break;
 971                                 }
 972
 973                                 if (!in_bounds2(y2, x2)) continue;
 974
 975                                 /* Ignore filled grids */
 976                                 if (!monster_can_enter(y2, x2, r_ptr, 0)) continue;
 977
 978                                 /* Try to fill this hole */
 979                                 break;
 980                         }
 981
 982                         /* Extract the new "pseudo-direction" */
 983                         y = m_ptr->fy - y2;
 984                         x = m_ptr->fx - x2;
 985
 986                         done = TRUE;
 987                 }
 988         }
 989
 990         if (!done)
 991         {
 992                 /* Flow towards the player */
 993                 (void)get_moves_aux(m_idx, &y2, &x2, no_flow);
 994
 995                 /* Extract the "pseudo-direction" */
 996                 y = m_ptr->fy - y2;
 997                 x = m_ptr->fx - x2;
 998
 999                 /* Not done */
1000         }
1001
1002         /* Apply fear if possible and necessary */
1003         if (is_pet(m_ptr) && will_run)
1004         {
1005                 /* XXX XXX Not very "smart" */
1006                 y = (-y), x = (-x);
1007         }
1008         else
1009         {
1010                 if (!done && will_run)
1011                 {
1012                         int tmp_x = (-x);
1013                         int tmp_y = (-y);
1014
1015                         /* Try to find safe place */
1016                         if (find_safety(m_idx, &y, &x))
1017                         {
1018                                 /* Attempt to avoid the player */
1019                                 if (!no_flow)
1020                                 {
1021                                         /* Adjust movement */
1022                                         if (get_fear_moves_aux(m_idx, &y, &x)) done = TRUE;
1023                                 }
1024                         }
1025
1026                         if (!done)
1027                         {
1028                                 /* This is not a very "smart" method XXX XXX */
1029                                 y = tmp_y;
1030                                 x = tmp_x;
1031                         }
1032                 }
1033         }
1034
1035
1036         /* Check for no move */
1037         if (!x && !y) return (FALSE);
1038
1039
1040         /* Extract the "absolute distances" */
1041         ax = ABS(x);
1042         ay = ABS(y);
1043
1044         /* Do something weird */
1045         if (y < 0) move_val += 8;
1046         if (x > 0) move_val += 4;
1047
1048         /* Prevent the diamond maneuvre */
1049         if (ay > (ax << 1)) move_val += 2;
1050         else if (ax > (ay << 1)) move_val++;
1051
1052         /* Extract some directions */
1053         switch (move_val)
1054         {
1055         case 0:
1056                 mm[0] = 9;
1057                 if (ay > ax)
1058                 {
1059                         mm[1] = 8;
1060                         mm[2] = 6;
1061                         mm[3] = 7;
1062                         mm[4] = 3;
1063                 }
1064                 else
1065                 {
1066                         mm[1] = 6;
1067                         mm[2] = 8;
1068                         mm[3] = 3;
1069                         mm[4] = 7;
1070                 }
1071                 break;
1072         case 1:
1073         case 9:
1074                 mm[0] = 6;
1075                 if (y < 0)
1076                 {
1077                         mm[1] = 3;
1078                         mm[2] = 9;
1079                         mm[3] = 2;
1080                         mm[4] = 8;
1081                 }
1082                 else
1083                 {
1084                         mm[1] = 9;
1085                         mm[2] = 3;
1086                         mm[3] = 8;
1087                         mm[4] = 2;
1088                 }
1089                 break;
1090         case 2:
1091         case 6:
1092                 mm[0] = 8;
1093                 if (x < 0)
1094                 {
1095                         mm[1] = 9;
1096                         mm[2] = 7;
1097                         mm[3] = 6;
1098                         mm[4] = 4;
1099                 }
1100                 else
1101                 {
1102                         mm[1] = 7;
1103                         mm[2] = 9;
1104                         mm[3] = 4;
1105                         mm[4] = 6;
1106                 }
1107                 break;
1108         case 4:
1109                 mm[0] = 7;
1110                 if (ay > ax)
1111                 {
1112                         mm[1] = 8;
1113                         mm[2] = 4;
1114                         mm[3] = 9;
1115                         mm[4] = 1;
1116                 }
1117                 else
1118                 {
1119                         mm[1] = 4;
1120                         mm[2] = 8;
1121                         mm[3] = 1;
1122                         mm[4] = 9;
1123                 }
1124                 break;
1125         case 5:
1126         case 13:
1127                 mm[0] = 4;
1128                 if (y < 0)
1129                 {
1130                         mm[1] = 1;
1131                         mm[2] = 7;
1132                         mm[3] = 2;
1133                         mm[4] = 8;
1134                 }
1135                 else
1136                 {
1137                         mm[1] = 7;
1138                         mm[2] = 1;
1139                         mm[3] = 8;
1140                         mm[4] = 2;
1141                 }
1142                 break;
1143         case 8:
1144                 mm[0] = 3;
1145                 if (ay > ax)
1146                 {
1147                         mm[1] = 2;
1148                         mm[2] = 6;
1149                         mm[3] = 1;
1150                         mm[4] = 9;
1151                 }
1152                 else
1153                 {
1154                         mm[1] = 6;
1155                         mm[2] = 2;
1156                         mm[3] = 9;
1157                         mm[4] = 1;
1158                 }
1159                 break;
1160         case 10:
1161         case 14:
1162                 mm[0] = 2;
1163                 if (x < 0)
1164                 {
1165                         mm[1] = 3;
1166                         mm[2] = 1;
1167                         mm[3] = 6;
1168                         mm[4] = 4;
1169                 }
1170                 else
1171                 {
1172                         mm[1] = 1;
1173                         mm[2] = 3;
1174                         mm[3] = 4;
1175                         mm[4] = 6;
1176                 }
1177                 break;
1178         case 12:
1179                 mm[0] = 1;
1180                 if (ay > ax)
1181                 {
1182                         mm[1] = 2;
1183                         mm[2] = 4;
1184                         mm[3] = 3;
1185                         mm[4] = 7;
1186                 }
1187                 else
1188                 {
1189                         mm[1] = 4;
1190                         mm[2] = 2;
1191                         mm[3] = 7;
1192                         mm[4] = 3;
1193                 }
1194                 break;
1195         }
1196
1197         /* Wants to move... */
1198         return (TRUE);
1199 }
1200
1201
1202 /*!
1203  * @brief モンスターから敵モンスターへの命中判定
1204  * @param power 打撃属性による基本命中値
1205  * @param level 攻撃側モンスターのレベル
1206  * @param ac 目標モンスターのAC
1207  * @param stun 攻撃側モンスターが朦朧状態ならTRUEを返す
1208  * @return 命中ならばTRUEを返す
1209  */
1210 static int check_hit2(int power, DEPTH level, ARMOUR_CLASS ac, int stun)
1211 {
1212         int i, k;
1213
1214         /* Percentile dice */
1215         k = randint0(100);
1216
1217         if (stun && one_in_(2)) return FALSE;
1218
1219         /* Hack -- Always miss or hit */
1220         if (k < 10) return (k < 5);
1221
1222         /* Calculate the "attack quality" */
1223         i = (power + (level * 3));
1224
1225         /* Power and Level compete against Armor */
1226         if ((i > 0) && (randint1(i) > ((ac * 3) / 4))) return (TRUE);
1227
1228         /* Assume miss */
1229         return (FALSE);
1230 }
1231
1232
1233 #define BLOW_EFFECT_TYPE_NONE  0
1234 #define BLOW_EFFECT_TYPE_FEAR  1
1235 #define BLOW_EFFECT_TYPE_SLEEP 2
1236 #define BLOW_EFFECT_TYPE_HEAL  3
1237
1238
1239 /*!
1240  * @brief モンスターから敵モンスターへの打撃攻撃処理
1241  * @param m_idx 攻撃側モンスターの参照ID
1242  * @param t_idx 目標側モンスターの参照ID
1243  * @return 実際に打撃処理が行われた場合TRUEを返す
1244  */
1245 static bool monst_attack_monst(MONSTER_IDX m_idx, MONSTER_IDX t_idx)
1246 {
1247         monster_type    *m_ptr = &current_floor_ptr->m_list[m_idx];
1248         monster_type    *t_ptr = &current_floor_ptr->m_list[t_idx];
1249
1250         monster_race    *r_ptr = &r_info[m_ptr->r_idx];
1251         monster_race    *tr_ptr = &r_info[t_ptr->r_idx];
1252
1253         ARMOUR_CLASS ap_cnt;
1254         ARMOUR_CLASS ac;
1255         DEPTH rlev;
1256         int pt;
1257         GAME_TEXT m_name[MAX_NLEN], t_name[MAX_NLEN];
1258         char            temp[MAX_NLEN];
1259         bool            blinked;
1260         bool            explode = FALSE, touched = FALSE, fear = FALSE, dead = FALSE;
1261         POSITION y_saver = t_ptr->fy;
1262         POSITION x_saver = t_ptr->fx;
1263         int             effect_type;
1264
1265         bool see_m = is_seen(m_ptr);
1266         bool see_t = is_seen(t_ptr);
1267         bool see_either = see_m || see_t;
1268
1269         /* Can the player be aware of this attack? */
1270         bool known = (m_ptr->cdis <= MAX_SIGHT) || (t_ptr->cdis <= MAX_SIGHT);
1271         bool do_silly_attack = (one_in_(2) && p_ptr->image);
1272
1273         /* Cannot attack self */
1274         if (m_idx == t_idx) return FALSE;
1275
1276         /* Not allowed to attack */
1277         if (r_ptr->flags1 & RF1_NEVER_BLOW) return FALSE;
1278
1279         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_NO_MELEE) return (FALSE);
1280
1281         /* Total armor */
1282         ac = tr_ptr->ac;
1283
1284         /* Extract the effective monster level */
1285         rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
1286
1287         monster_desc(m_name, m_ptr, 0);
1288         monster_desc(t_name, t_ptr, 0);
1289
1290         /* Assume no blink */
1291         blinked = FALSE;
1292
1293         if (!see_either && known)
1294         {
1295                 mon_fight = TRUE;
1296         }
1297
1298         if (p_ptr->riding && (m_idx == p_ptr->riding)) disturb(TRUE, TRUE);
1299
1300         /* Scan through all four blows */
1301         for (ap_cnt = 0; ap_cnt < 4; ap_cnt++)
1302         {
1303                 bool obvious = FALSE;
1304
1305                 HIT_POINT power = 0;
1306                 HIT_POINT damage = 0;
1307
1308                 concptr act = NULL;
1309
1310                 /* Extract the attack infomation */
1311                 int effect = r_ptr->blow[ap_cnt].effect;
1312                 int method = r_ptr->blow[ap_cnt].method;
1313                 int d_dice = r_ptr->blow[ap_cnt].d_dice;
1314                 int d_side = r_ptr->blow[ap_cnt].d_side;
1315
1316                 if (!monster_is_valid(m_ptr)) break;
1317
1318                 /* Stop attacking if the target dies! */
1319                 if (t_ptr->fx != x_saver || t_ptr->fy != y_saver)
1320                         break;
1321
1322                 /* Hack -- no more attacks */
1323                 if (!method) break;
1324
1325                 if (method == RBM_SHOOT) continue;
1326
1327                 /* Extract the attack "power" */
1328                 power = mbe_info[effect].power;
1329
1330                 /* Monster hits */
1331                 if (!effect || check_hit2(power, rlev, ac, MON_STUNNED(m_ptr)))
1332                 {
1333                         (void)set_monster_csleep(t_idx, 0);
1334
1335                         if (t_ptr->ml)
1336                         {
1337                                 /* Redraw the health bar */
1338                                 if (p_ptr->health_who == t_idx) p_ptr->redraw |= (PR_HEALTH);
1339                                 if (p_ptr->riding == t_idx) p_ptr->redraw |= (PR_UHEALTH);
1340                         }
1341
1342                         /* Describe the attack method */
1343                         switch (method)
1344                         {
1345                         case RBM_HIT:
1346                                 {
1347                                         act = _("%sを殴った。", "hits %s.");
1348                                         touched = TRUE;
1349                                         break;
1350                                 }
1351
1352                         case RBM_TOUCH:
1353                                 {
1354                                         act = _("%sを触った。", "touches %s.");
1355                                         touched = TRUE;
1356                                         break;
1357                                 }
1358
1359                         case RBM_PUNCH:
1360                                 {
1361                                         act = _("%sをパンチした。", "punches %s.");
1362                                         touched = TRUE;
1363                                         break;
1364                                 }
1365
1366                         case RBM_KICK:
1367                                 {
1368                                         act = _("%sを蹴った。", "kicks %s.");
1369                                         touched = TRUE;
1370                                         break;
1371                                 }
1372
1373                         case RBM_CLAW:
1374                                 {
1375                                         act = _("%sをひっかいた。", "claws %s.");
1376                                         touched = TRUE;
1377                                         break;
1378                                 }
1379
1380                         case RBM_BITE:
1381                                 {
1382                                         act = _("%sを噛んだ。", "bites %s.");
1383                                         touched = TRUE;
1384                                         break;
1385                                 }
1386
1387                         case RBM_STING:
1388                                 {
1389                                         act = _("%sを刺した。", "stings %s.");
1390                                         touched = TRUE;
1391                                         break;
1392                                 }
1393
1394                         case RBM_SLASH:
1395                                 {
1396                                         act = _("%sを斬った。", "slashes %s.");
1397                                         break;
1398                                 }
1399
1400                         case RBM_BUTT:
1401                                 {
1402                                         act = _("%sを角で突いた。", "butts %s.");
1403                                         touched = TRUE;
1404                                         break;
1405                                 }
1406
1407                         case RBM_CRUSH:
1408                                 {
1409                                         act = _("%sに体当りした。", "crushes %s.");
1410                                         touched = TRUE;
1411                                         break;
1412                                 }
1413
1414                         case RBM_ENGULF:
1415                                 {
1416                                         act = _("%sを飲み込んだ。", "engulfs %s.");
1417                                         touched = TRUE;
1418                                         break;
1419                                 }
1420
1421                         case RBM_CHARGE:
1422                                 {
1423                                         act = _("%sに請求書をよこした。", "charges %s.");
1424                                         touched = TRUE;
1425                                         break;
1426                                 }
1427
1428                         case RBM_CRAWL:
1429                                 {
1430                                         act = _("%sの体の上を這い回った。", "crawls on %s.");
1431                                         touched = TRUE;
1432                                         break;
1433                                 }
1434
1435                         case RBM_DROOL:
1436                                 {
1437                                         act = _("%sによだれをたらした。", "drools on %s.");
1438                                         touched = FALSE;
1439                                         break;
1440                                 }
1441
1442                         case RBM_SPIT:
1443                                 {
1444                                         act = _("%sに唾を吐いた。", "spits on %s.");
1445                                         touched = FALSE;
1446                                         break;
1447                                 }
1448
1449                         case RBM_EXPLODE:
1450                                 {
1451                                         if (see_either) disturb(TRUE, TRUE);
1452                                         act = _("爆発した。", "explodes.");
1453                                         explode = TRUE;
1454                                         touched = FALSE;
1455                                         break;
1456                                 }
1457
1458                         case RBM_GAZE:
1459                                 {
1460                                         act = _("%sをにらんだ。", "gazes at %s.");
1461                                         touched = FALSE;
1462                                         break;
1463                                 }
1464
1465                         case RBM_WAIL:
1466                                 {
1467                                         act = _("%sに泣きついた。", "wails at %s.");
1468                                         touched = FALSE;
1469                                         break;
1470                                 }
1471
1472                         case RBM_SPORE:
1473                                 {
1474                                         act = _("%sに胞子を飛ばした。", "releases spores at %s.");
1475                                         touched = FALSE;
1476                                         break;
1477                                 }
1478
1479                         case RBM_XXX4:
1480                                 {
1481                                         act = _("%sにXXX4を飛ばした。", "projects XXX4's at %s.");
1482                                         touched = FALSE;
1483                                         break;
1484                                 }
1485
1486                         case RBM_BEG:
1487                                 {
1488                                         act = _("%sに金をせがんだ。", "begs %s for money.");
1489                                         touched = FALSE;
1490                                         break;
1491                                 }
1492
1493                         case RBM_INSULT:
1494                                 {
1495                                         act = _("%sを侮辱した。", "insults %s.");
1496                                         touched = FALSE;
1497                                         break;
1498                                 }
1499
1500                         case RBM_MOAN:
1501                                 {
1502                                         act = _("%sにむかってうめいた。", "moans at %s.");
1503                                         touched = FALSE;
1504                                         break;
1505                                 }
1506
1507                         case RBM_SHOW:
1508                                 {
1509                                         act = _("%sにむかって歌った。", "sings to %s.");
1510                                         touched = FALSE;
1511                                         break;
1512                                 }
1513                         }
1514
1515                         if (act && see_either)
1516                         {
1517 #ifdef JP
1518                                 if (do_silly_attack) act = silly_attacks2[randint0(MAX_SILLY_ATTACK)];
1519                                 strfmt(temp, act, t_name);
1520                                 msg_format("%^sは%s", m_name, temp);
1521 #else
1522                                 if (do_silly_attack)
1523                                 {
1524                                         act = silly_attacks[randint0(MAX_SILLY_ATTACK)];
1525                                         strfmt(temp, "%s %s.", act, t_name);
1526                                 }
1527                                 else strfmt(temp, act, t_name);
1528                                 msg_format("%^s %s", m_name, temp);
1529 #endif
1530                         }
1531
1532                         /* Hack -- assume all attacks are obvious */
1533                         obvious = TRUE;
1534
1535                         /* Roll out the damage */
1536                         damage = damroll(d_dice, d_side);
1537
1538                         /* Assume no effect */
1539                         effect_type = BLOW_EFFECT_TYPE_NONE;
1540
1541                         pt = GF_MISSILE;
1542
1543                         /* Apply appropriate damage */
1544                         switch (effect)
1545                         {
1546                         case 0:
1547                         case RBE_DR_MANA:
1548                                 damage = pt = 0;
1549                                 break;
1550
1551                         case RBE_SUPERHURT:
1552                                 if ((randint1(rlev*2+250) > (ac+200)) || one_in_(13))
1553                                 {
1554                                         int tmp_damage = damage - (damage * ((ac < 150) ? ac : 150) / 250);
1555                                         damage = MAX(damage, tmp_damage * 2);
1556                                         break;
1557                                 }
1558
1559                                 /* Fall through */
1560
1561                         case RBE_HURT:
1562                                 damage -= (damage * ((ac < 150) ? ac : 150) / 250);
1563                                 break;
1564
1565                         case RBE_POISON:
1566                         case RBE_DISEASE:
1567                                 pt = GF_POIS;
1568                                 break;
1569
1570                         case RBE_UN_BONUS:
1571                         case RBE_UN_POWER:
1572                                 pt = GF_DISENCHANT;
1573                                 break;
1574
1575                         case RBE_EAT_ITEM:
1576                         case RBE_EAT_GOLD:
1577                                 if ((p_ptr->riding != m_idx) && one_in_(2)) blinked = TRUE;
1578                                 break;
1579
1580                         case RBE_EAT_FOOD:
1581                         case RBE_EAT_LITE:
1582                         case RBE_BLIND:
1583                         case RBE_LOSE_STR:
1584                         case RBE_LOSE_INT:
1585                         case RBE_LOSE_WIS:
1586                         case RBE_LOSE_DEX:
1587                         case RBE_LOSE_CON:
1588                         case RBE_LOSE_CHR:
1589                         case RBE_LOSE_ALL:
1590                                 break;
1591
1592                         case RBE_ACID:
1593                                 pt = GF_ACID;
1594                                 break;
1595
1596                         case RBE_ELEC:
1597                                 pt = GF_ELEC;
1598                                 break;
1599
1600                         case RBE_FIRE:
1601                                 pt = GF_FIRE;
1602                                 break;
1603
1604                         case RBE_COLD:
1605                                 pt = GF_COLD;
1606                                 break;
1607
1608                         case RBE_CONFUSE:
1609                                 pt = GF_CONFUSION;
1610                                 break;
1611
1612                         case RBE_TERRIFY:
1613                                 effect_type = BLOW_EFFECT_TYPE_FEAR;
1614                                 break;
1615
1616                         case RBE_PARALYZE:
1617                                 effect_type = BLOW_EFFECT_TYPE_SLEEP;
1618                                 break;
1619
1620                         case RBE_SHATTER:
1621                                 damage -= (damage * ((ac < 150) ? ac : 150) / 250);
1622                                 if (damage > 23) earthquake_aux(m_ptr->fy, m_ptr->fx, 8, m_idx);
1623                                 break;
1624
1625                         case RBE_EXP_10:
1626                         case RBE_EXP_20:
1627                         case RBE_EXP_40:
1628                         case RBE_EXP_80:
1629                                 pt = GF_NETHER;
1630                                 break;
1631
1632                         case RBE_TIME:
1633                                 pt = GF_TIME;
1634                                 break;
1635
1636                         case RBE_DR_LIFE:
1637                                 pt = GF_HYPODYNAMIA;
1638                                 effect_type = BLOW_EFFECT_TYPE_HEAL;
1639                                 break;
1640
1641                         case RBE_INERTIA:
1642                                 pt = GF_INERTIAL;
1643                                 break;
1644
1645                         case RBE_STUN:
1646                                 pt = GF_SOUND;
1647                                 break;
1648
1649                         default:
1650                                 pt = 0;
1651                                 break;
1652                         }
1653
1654                         if (pt)
1655                         {
1656                                 /* Do damage if not exploding */
1657                                 if (!explode)
1658                                 {
1659                                         project(m_idx, 0, t_ptr->fy, t_ptr->fx,
1660                                                 damage, pt, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
1661                                 }
1662
1663                                 switch (effect_type)
1664                                 {
1665                                 case BLOW_EFFECT_TYPE_FEAR:
1666                                         project(m_idx, 0, t_ptr->fy, t_ptr->fx,
1667                                                 damage, GF_TURN_ALL, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
1668                                         break;
1669
1670                                 case BLOW_EFFECT_TYPE_SLEEP:
1671                                         project(m_idx, 0, t_ptr->fy, t_ptr->fx,
1672                                                 r_ptr->level, GF_OLD_SLEEP, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
1673                                         break;
1674
1675                                 case BLOW_EFFECT_TYPE_HEAL:
1676                                         if ((monster_living(m_idx)) && (damage > 2))
1677                                         {
1678                                                 bool did_heal = FALSE;
1679
1680                                                 if (m_ptr->hp < m_ptr->maxhp) did_heal = TRUE;
1681
1682                                                 /* Heal */
1683                                                 m_ptr->hp += damroll(4, damage / 6);
1684                                                 if (m_ptr->hp > m_ptr->maxhp) m_ptr->hp = m_ptr->maxhp;
1685
1686                                                 /* Redraw (later) if needed */
1687                                                 if (p_ptr->health_who == m_idx) p_ptr->redraw |= (PR_HEALTH);
1688                                                 if (p_ptr->riding == m_idx) p_ptr->redraw |= (PR_UHEALTH);
1689
1690                                                 /* Special message */
1691                                                 if (see_m && did_heal)
1692                                                 {
1693                                                         msg_format(_("%sは体力を回復したようだ。", "%^s appears healthier."), m_name);
1694                                                 }
1695                                         }
1696                                         break;
1697                                 }
1698
1699                                 if (touched)
1700                                 {
1701                                         /* Aura fire */
1702                                         if ((tr_ptr->flags2 & RF2_AURA_FIRE) && m_ptr->r_idx)
1703                                         {
1704                                                 if (!(r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK))
1705                                                 {
1706                                                         if (see_either)
1707                                                         {
1708                                                                 msg_format(_("%^sは突然熱くなった！", "%^s is suddenly very hot!"), m_name);
1709                                                         }
1710                                                         if (m_ptr->ml && is_original_ap_and_seen(t_ptr)) tr_ptr->r_flags2 |= RF2_AURA_FIRE;
1711                                                         project(t_idx, 0, m_ptr->fy, m_ptr->fx,
1712                                                                 damroll (1 + ((tr_ptr->level) / 26),
1713                                                                 1 + ((tr_ptr->level) / 17)),
1714                                                                 GF_FIRE, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
1715                                                 }
1716                                                 else
1717                                                 {
1718                                                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK);
1719                                                 }
1720                                         }
1721
1722                                         /* Aura cold */
1723                                         if ((tr_ptr->flags3 & RF3_AURA_COLD) && m_ptr->r_idx)
1724                                         {
1725                                                 if (!(r_ptr->flagsr & RFR_EFF_IM_COLD_MASK))
1726                                                 {
1727                                                         if (see_either)
1728                                                         {
1729                                                                 msg_format(_("%^sは突然寒くなった！", "%^s is suddenly very cold!"), m_name);
1730                                                         }
1731                                                         if (m_ptr->ml && is_original_ap_and_seen(t_ptr)) tr_ptr->r_flags3 |= RF3_AURA_COLD;
1732                                                         project(t_idx, 0, m_ptr->fy, m_ptr->fx,
1733                                                                 damroll (1 + ((tr_ptr->level) / 26),
1734                                                                 1 + ((tr_ptr->level) / 17)),
1735                                                                 GF_COLD, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
1736                                                 }
1737                                                 else
1738                                                 {
1739                                                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_COLD_MASK);
1740                                                 }
1741                                         }
1742
1743                                         /* Aura elec */
1744                                         if ((tr_ptr->flags2 & RF2_AURA_ELEC) && m_ptr->r_idx)
1745                                         {
1746                                                 if (!(r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK))
1747                                                 {
1748                                                         if (see_either)
1749                                                         {
1750                                                                 msg_format(_("%^sは電撃を食らった！", "%^s gets zapped!"), m_name);
1751                                                         }
1752                                                         if (m_ptr->ml && is_original_ap_and_seen(t_ptr)) tr_ptr->r_flags2 |= RF2_AURA_ELEC;
1753                                                         project(t_idx, 0, m_ptr->fy, m_ptr->fx,
1754                                                                 damroll (1 + ((tr_ptr->level) / 26),
1755                                                                 1 + ((tr_ptr->level) / 17)),
1756                                                                 GF_ELEC, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
1757                                                 }
1758                                                 else
1759                                                 {
1760                                                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK);
1761                                                 }
1762                                         }
1763                                 }
1764                         }
1765                 }
1766
1767                 /* Monster missed player */
1768                 else
1769                 {
1770                         /* Analyze failed attacks */
1771                         switch (method)
1772                         {
1773                         case RBM_HIT:
1774                         case RBM_TOUCH:
1775                         case RBM_PUNCH:
1776                         case RBM_KICK:
1777                         case RBM_CLAW:
1778                         case RBM_BITE:
1779                         case RBM_STING:
1780                         case RBM_SLASH:
1781                         case RBM_BUTT:
1782                         case RBM_CRUSH:
1783                         case RBM_ENGULF:
1784                         case RBM_CHARGE:
1785                                 {
1786                                         (void)set_monster_csleep(t_idx, 0);
1787
1788                                         /* Visible monsters */
1789                                         if (see_m)
1790                                         {
1791 #ifdef JP
1792                                                 msg_format("%sは%^sの攻撃をかわした。", t_name, m_name);
1793 #else
1794                                                 msg_format("%^s misses %s.", m_name, t_name);
1795 #endif
1796                                         }
1797
1798                                         break;
1799                                 }
1800                         }
1801                 }
1802
1803
1804                 /* Analyze "visible" monsters only */
1805                 if (is_original_ap_and_seen(m_ptr) && !do_silly_attack)
1806                 {
1807                         /* Count "obvious" attacks (and ones that cause damage) */
1808                         if (obvious || damage || (r_ptr->r_blows[ap_cnt] > 10))
1809                         {
1810                                 /* Count attacks of this type */
1811                                 if (r_ptr->r_blows[ap_cnt] < MAX_UCHAR)
1812                                 {
1813                                         r_ptr->r_blows[ap_cnt]++;
1814                                 }
1815                         }
1816                 }
1817         }
1818
1819         if (explode)
1820         {
1821                 sound(SOUND_EXPLODE);
1822
1823                 /* Cancel Invulnerability */
1824                 (void)set_monster_invulner(m_idx, 0, FALSE);
1825                 mon_take_hit_mon(m_idx, m_ptr->hp + 1, &dead, &fear, _("は爆発して粉々になった。", " explodes into tiny shreds."), m_idx);
1826                 blinked = FALSE;
1827         }
1828
1829         /* Blink away */
1830         if (blinked && m_ptr->r_idx)
1831         {
1832                 if (teleport_barrier(m_idx))
1833                 {
1834                         if (see_m)
1835                         {
1836                                 msg_print(_("泥棒は笑って逃げ...ようとしたがバリアに防がれた。", "The thief flees laughing...? But magic barrier obstructs it."));
1837                         }
1838                         else if (known)
1839                         {
1840                                 mon_fight = TRUE;
1841                         }
1842                 }
1843                 else
1844                 {
1845                         if (see_m)
1846                         {
1847                                 msg_print(_("泥棒は笑って逃げた！", "The thief flees laughing!"));
1848                         }
1849                         else if (known)
1850                         {
1851                                 mon_fight = TRUE;
1852                         }
1853
1854                         teleport_away(m_idx, MAX_SIGHT * 2 + 5, 0L);
1855                 }
1856         }
1857
1858         return TRUE;
1859 }
1860
1861
1862 static bool check_hp_for_feat_destruction(feature_type *f_ptr, monster_type *m_ptr)
1863 {
1864         return !have_flag(f_ptr->flags, FF_GLASS) ||
1865                 (r_info[m_ptr->r_idx].flags2 & RF2_STUPID) ||
1866                 (m_ptr->hp >= MAX(m_ptr->maxhp / 3, 200));
1867 }
1868
1869
1870 /*!
1871  * @brief モンスター単体の１ターン行動処理メインルーチン /
1872  * Process a monster
1873  * @param m_idx 行動モンスターの参照ID
1874  * @return なし
1875  * @details
1876  * The monster is known to be within 100 grids of the player\n
1877  *\n
1878  * In several cases, we directly update the monster lore\n
1879  *\n
1880  * Note that a monster is only allowed to "reproduce" if there\n
1881  * are a limited number of "reproducing" monsters on the current\n
1882  * level.  This should prevent the level from being "swamped" by\n
1883  * reproducing monsters.  It also allows a large mass of mice to\n
1884  * prevent a louse from multiplying, but this is a small price to\n
1885  * pay for a simple multiplication method.\n
1886  *\n
1887  * XXX Monster fear is slightly odd, in particular, monsters will\n
1888  * fixate on opening a door even if they cannot open it.  Actually,\n
1889  * the same thing happens to normal monsters when they hit a door\n
1890  *\n
1891  * In addition, monsters which *cannot* open or bash\n
1892  * down a door will still stand there trying to open it...\n
1893  *\n
1894  * XXX Technically, need to check for monster in the way\n
1895  * combined with that monster being in a wall (or door?)\n
1896  *\n
1897  * A "direction" of "5" means "pick a random direction".\n
1898  */
1899 void process_monster(MONSTER_IDX m_idx)
1900 {
1901         monster_type    *m_ptr = &current_floor_ptr->m_list[m_idx];
1902         monster_race    *r_ptr = &r_info[m_ptr->r_idx];
1903         monster_race    *ap_r_ptr = &r_info[m_ptr->ap_r_idx];
1904
1905         int i, d;
1906         POSITION oy, ox, ny, nx;
1907
1908         DIRECTION mm[8];
1909
1910         grid_type       *g_ptr;
1911         feature_type    *f_ptr;
1912
1913         monster_type    *y_ptr;
1914
1915         bool            do_turn;
1916         bool            do_move;
1917         bool            do_view;
1918         bool            must_alter_to_move;
1919
1920         bool            did_open_door;
1921         bool            did_bash_door;
1922         bool            did_take_item;
1923         bool            did_kill_item;
1924         bool            did_move_body;
1925         bool            did_pass_wall;
1926         bool            did_kill_wall;
1927         bool            gets_angry = FALSE;
1928         bool            can_cross;
1929         bool            aware = TRUE;
1930
1931         bool fear, dead;
1932         bool is_riding_mon = (m_idx == p_ptr->riding);
1933         bool see_m = is_seen(m_ptr);
1934
1935         if (is_riding_mon && !(r_ptr->flags7 & RF7_RIDING))
1936         {
1937                 if (rakuba(0, TRUE))
1938                 {
1939 #ifdef JP
1940                         msg_print("地面に落とされた。");
1941 #else
1942                         GAME_TEXT m_name[MAX_NLEN];
1943                         monster_desc(m_name, &current_floor_ptr->m_list[p_ptr->riding], 0);
1944                         msg_format("You have fallen from %s.", m_name);
1945 #endif
1946                 }
1947         }
1948
1949         if ((m_ptr->mflag2 & MFLAG2_CHAMELEON) && one_in_(13) && !MON_CSLEEP(m_ptr))
1950         {
1951                 choose_new_monster(m_idx, FALSE, 0);
1952                 r_ptr = &r_info[m_ptr->r_idx];
1953         }
1954
1955         /* Players hidden in shadow are almost imperceptable. -LM- */
1956         if (p_ptr->special_defense & NINJA_S_STEALTH)
1957         {
1958                 int tmp = p_ptr->lev*6+(p_ptr->skill_stl+10)*4;
1959                 if (p_ptr->monlite) tmp /= 3;
1960                 if (p_ptr->cursed & TRC_AGGRAVATE) tmp /= 2;
1961                 if (r_ptr->level > (p_ptr->lev * p_ptr->lev / 20 + 10)) tmp /= 3;
1962                 /* Low-level monsters will find it difficult to locate the player. */
1963                 if (randint0(tmp) > (r_ptr->level+20)) aware = FALSE;
1964         }
1965
1966         /* Are there its parent? */
1967         if (m_ptr->parent_m_idx && !current_floor_ptr->m_list[m_ptr->parent_m_idx].r_idx)
1968         {
1969                 /* Its parent have gone, it also goes away. */
1970
1971                 if (see_m)
1972                 {
1973                         GAME_TEXT m_name[MAX_NLEN];
1974                         monster_desc(m_name, m_ptr, 0);
1975                         msg_format(_("%sは消え去った！", "%^s disappears!"), m_name);
1976                 }
1977
1978                 if (record_named_pet && is_pet(m_ptr) && m_ptr->nickname)
1979                 {
1980                         GAME_TEXT m_name[MAX_NLEN];
1981                         monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
1982                         do_cmd_write_nikki(NIKKI_NAMED_PET, RECORD_NAMED_PET_LOSE_PARENT, m_name);
1983                 }
1984
1985                 delete_monster_idx(m_idx);
1986
1987                 return;
1988         }
1989
1990         /* Quantum monsters are odd */
1991         if (r_ptr->flags2 & (RF2_QUANTUM))
1992         {
1993                 /* Sometimes skip move */
1994                 if (!randint0(2)) return;
1995
1996                 /* Sometimes die */
1997                 if (!randint0((m_idx % 100) + 10) && !(r_ptr->flags1 & RF1_QUESTOR))
1998                 {
1999                         bool sad = FALSE;
2000
2001                         if (is_pet(m_ptr) && !(m_ptr->ml)) sad = TRUE;
2002
2003                         if (see_m)
2004                         {
2005                                 GAME_TEXT m_name[MAX_NLEN];
2006                                 monster_desc(m_name, m_ptr, 0);
2007
2008                                 msg_format(_("%sは消え去った！", "%^s disappears!"), m_name);
2009                         }
2010
2011                         /* Generate treasure, etc */
2012                         monster_death(m_idx, FALSE);
2013
2014                         delete_monster_idx(m_idx);
2015                         if (sad)
2016                         {
2017                                 msg_print(_("少しの間悲しい気分になった。", "You feel sad for a moment."));
2018                         }
2019
2020                         return;
2021                 }
2022         }
2023
2024         if (m_ptr->r_idx == MON_SHURYUUDAN)
2025         {
2026                 mon_take_hit_mon(m_idx, 1, &dead, &fear, _("は爆発して粉々になった。", " explodes into tiny shreds."), m_idx);
2027                 if(dead) return;
2028         }
2029
2030         if ((is_pet(m_ptr) || is_friendly(m_ptr)) && ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)) && !p_ptr->inside_battle)
2031         {
2032                 static int riding_pinch = 0;
2033
2034                 if (m_ptr->hp < m_ptr->maxhp/3)
2035                 {
2036                         GAME_TEXT m_name[MAX_NLEN];
2037                         monster_desc(m_name, m_ptr, 0);
2038
2039                         if (is_riding_mon && riding_pinch < 2)
2040                         {
2041                                 msg_format(_("%sは傷の痛さの余りあなたの束縛から逃れようとしている。",
2042                                                          "%^s seems to be in so much pain, and trying to escape from your restriction."), m_name);
2043                                 riding_pinch++;
2044                                 disturb(TRUE, TRUE);
2045                         }
2046                         else
2047                         {
2048                                 if (is_riding_mon)
2049                                 {
2050                                         msg_format(_("%sはあなたの束縛から脱出した。", "%^s succeeded to escape from your restriction!"), m_name);
2051                                         if (rakuba(-1, FALSE))
2052                                         {
2053                                                 msg_print(_("地面に落とされた。", "You have fallen from riding pet."));
2054                                         }
2055                                 }
2056
2057                                 if (see_m)
2058                                 {
2059                                         if ((r_ptr->flags2 & RF2_CAN_SPEAK) && (m_ptr->r_idx != MON_GRIP) && (m_ptr->r_idx != MON_WOLF) && (m_ptr->r_idx != MON_FANG) &&
2060                                             player_has_los_bold(m_ptr->fy, m_ptr->fx) && projectable(m_ptr->fy, m_ptr->fx, p_ptr->y, p_ptr->x))
2061                                         {
2062                                                 msg_format(_("%^s「ピンチだ！退却させてもらう！」", "%^s says 'It is the pinch! I will retreat'."), m_name);
2063                                         }
2064                                         msg_format(_("%^sがテレポート・レベルの巻物を読んだ。", "%^s read a scroll of teleport level."), m_name);
2065                                         msg_format(_("%^sが消え去った。", "%^s disappears."), m_name);
2066                                 }
2067
2068                                 if (is_riding_mon && rakuba(-1, FALSE))
2069                                 {
2070                                         msg_print(_("地面に落とされた。", "You have fallen from riding pet."));
2071                                 }
2072
2073                                 check_quest_completion(m_ptr);
2074                                 delete_monster_idx(m_idx);
2075                                 return;
2076                         }
2077                 }
2078                 else
2079                 {
2080                         /* Reset the counter */
2081                         if (is_riding_mon) riding_pinch = 0;
2082                 }
2083         }
2084
2085         /* Handle "sleep" */
2086         if (MON_CSLEEP(m_ptr))
2087         {
2088                 /* Handle non-aggravation - Still sleeping */
2089                 if (!(p_ptr->cursed & TRC_AGGRAVATE)) return;
2090
2091                 (void)set_monster_csleep(m_idx, 0);
2092
2093                 /* Notice the "waking up" */
2094                 if (m_ptr->ml)
2095                 {
2096                         GAME_TEXT m_name[MAX_NLEN];
2097                         monster_desc(m_name, m_ptr, 0);
2098                         msg_format(_("%^sが目を覚ました。", "%^s wakes up."), m_name);
2099                 }
2100
2101                 /* Hack -- Count the wakings */
2102                 if (is_original_ap_and_seen(m_ptr) && (r_ptr->r_wake < MAX_UCHAR))
2103                 {
2104                         r_ptr->r_wake++;
2105                 }
2106         }
2107
2108         /* Handle "stun" */
2109         if (MON_STUNNED(m_ptr))
2110         {
2111                 /* Sometimes skip move */
2112                 if (one_in_(2)) return;
2113         }
2114
2115         if (is_riding_mon)
2116         {
2117                 p_ptr->update |= (PU_BONUS);
2118         }
2119
2120         /* No one wants to be your friend if you're aggravating */
2121         if (is_friendly(m_ptr) && (p_ptr->cursed & TRC_AGGRAVATE))
2122                 gets_angry = TRUE;
2123
2124         /* Paranoia... no pet uniques outside wizard mode -- TY */
2125         if (is_pet(m_ptr) && ((((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)) &&
2126               monster_has_hostile_align(NULL, 10, -10, r_ptr)) || (r_ptr->flagsr & RFR_RES_ALL)))
2127         {
2128                 gets_angry = TRUE;
2129         }
2130
2131         if (p_ptr->inside_battle) gets_angry = FALSE;
2132
2133         if (gets_angry)
2134         {
2135                 if (is_pet(m_ptr) || see_m)
2136                 {
2137                         GAME_TEXT m_name[MAX_NLEN];
2138                         monster_desc(m_name, m_ptr, is_pet(m_ptr) ? MD_ASSUME_VISIBLE : 0);
2139                         msg_format(_("%^sは突然敵にまわった！", "%^s suddenly becomes hostile!"), m_name);
2140                 }
2141
2142                 set_hostile(m_ptr);
2143         }
2144
2145         /* Get the origin */
2146         oy = m_ptr->fy;
2147         ox = m_ptr->fx;
2148
2149         /* Attempt to "multiply" if able and allowed */
2150         if ((r_ptr->flags2 & RF2_MULTIPLY) && (current_floor_ptr->num_repro < MAX_REPRO))
2151         {
2152                 int k;
2153                 POSITION y, x;
2154
2155                 /* Count the adjacent monsters */
2156                 for (k = 0, y = oy - 1; y <= oy + 1; y++)
2157                 {
2158                         for (x = ox - 1; x <= ox + 1; x++)
2159                         {
2160                                 /* Ignore locations off of edge */
2161                                 if (!in_bounds2(y, x)) continue;
2162                                 if (current_floor_ptr->grid_array[y][x].m_idx) k++;
2163                         }
2164                 }
2165
2166                 /* Hex */
2167                 if (multiply_barrier(m_idx)) k = 8;
2168
2169                 /* Hack -- multiply slower in crowded areas */
2170                 if ((k < 4) && (!k || !randint0(k * MON_MULT_ADJ)))
2171                 {
2172                         /* Try to multiply */
2173                         if (multiply_monster(m_idx, FALSE, (is_pet(m_ptr) ? PM_FORCE_PET : 0)))
2174                         {
2175                                 /* Take note if visible */
2176                                 if (current_floor_ptr->m_list[hack_m_idx_ii].ml && is_original_ap_and_seen(m_ptr))
2177                                 {
2178                                         r_ptr->r_flags2 |= (RF2_MULTIPLY);
2179                                 }
2180
2181                                 /* Multiplying takes energy */
2182                                 return;
2183                         }
2184                 }
2185         }
2186
2187         if (r_ptr->a_ability_flags2 & RF6_SPECIAL)
2188         {
2189                 /* Hack -- Ohmu scatters molds! */
2190                 if (m_ptr->r_idx == MON_OHMU)
2191                 {
2192                         if (!p_ptr->inside_arena && !p_ptr->inside_battle)
2193                         {
2194                                 if (r_ptr->freq_spell && (randint1(100) <= r_ptr->freq_spell))
2195                                 {
2196                                         int k, count = 0;
2197                                         DEPTH rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
2198                                         BIT_FLAGS p_mode = is_pet(m_ptr) ? PM_FORCE_PET : 0L;
2199
2200                                         for (k = 0; k < A_MAX; k++)
2201                                         {
2202                                                 if (summon_specific(m_idx, m_ptr->fy, m_ptr->fx, rlev, SUMMON_MOLD, (PM_ALLOW_GROUP | p_mode), '\0'))
2203                                                 {
2204                                                         if (current_floor_ptr->m_list[hack_m_idx_ii].ml) count++;
2205                                                 }
2206                                         }
2207
2208                                         if (count && is_original_ap_and_seen(m_ptr)) r_ptr->r_flags6 |= (RF6_SPECIAL);
2209                                 }
2210                         }
2211                 }
2212         }
2213
2214         if (!p_ptr->inside_battle)
2215         {
2216                 /* Hack! "Cyber" monster makes noise... */
2217                 if (m_ptr->ap_r_idx == MON_CYBER &&
2218                     one_in_(CYBERNOISE) &&
2219                     !m_ptr->ml && (m_ptr->cdis <= MAX_SIGHT))
2220                 {
2221                         if (disturb_minor) disturb(FALSE, FALSE);
2222                         msg_print(_("重厚な足音が聞こえた。", "You hear heavy steps."));
2223                 }
2224
2225                 /* Some monsters can speak */
2226                 if ((ap_r_ptr->flags2 & RF2_CAN_SPEAK) && aware &&
2227                     one_in_(SPEAK_CHANCE) &&
2228                     player_has_los_bold(oy, ox) &&
2229                     projectable(oy, ox, p_ptr->y, p_ptr->x))
2230                 {
2231                         GAME_TEXT m_name[MAX_NLEN];
2232                         char monmessage[1024];
2233                         concptr filename;
2234
2235                         /* Acquire the monster name/poss */
2236                         if (m_ptr->ml)
2237                                 monster_desc(m_name, m_ptr, 0);
2238                         else
2239                                 strcpy(m_name, _("それ", "It"));
2240
2241                         /* Select the file for monster quotes */
2242                         if (MON_MONFEAR(m_ptr))
2243                                 filename = _("monfear_j.txt", "monfear.txt");
2244                         else if (is_pet(m_ptr))
2245                                 filename = _("monpet_j.txt", "monpet.txt");
2246                         else if (is_friendly(m_ptr))
2247                                 filename = _("monfrien_j.txt", "monfrien.txt");
2248                         else
2249                                 filename = _("monspeak_j.txt", "monspeak.txt");
2250                         /* Get the monster line */
2251                         if (get_rnd_line(filename, m_ptr->ap_r_idx, monmessage) == 0)
2252                         {
2253                                 /* Say something */
2254                                 msg_format(_("%^s%s", "%^s %s"), m_name, monmessage);
2255                         }
2256                 }
2257         }
2258
2259         /* Try to cast spell occasionally */
2260         if (r_ptr->freq_spell && randint1(100) <= r_ptr->freq_spell)
2261         {
2262                 bool counterattack = FALSE;
2263
2264                 /* Give priority to counter attack? */
2265                 if (m_ptr->target_y)
2266                 {
2267                         MONSTER_IDX t_m_idx = current_floor_ptr->grid_array[m_ptr->target_y][m_ptr->target_x].m_idx;
2268
2269                         /* The monster must be an enemy, and projectable */
2270                         if (t_m_idx && are_enemies(m_ptr, &current_floor_ptr->m_list[t_m_idx]) &&
2271                             projectable(m_ptr->fy, m_ptr->fx, m_ptr->target_y, m_ptr->target_x))
2272                         {
2273                                 counterattack = TRUE;
2274                         }
2275                 }
2276
2277                 if (!counterattack)
2278                 {
2279                         /* Attempt to cast a spell */
2280                         if (aware && make_attack_spell(m_idx)) return;
2281
2282                         /*
2283                          * Attempt to cast a spell at an enemy other than the player
2284                          * (may slow the game a smidgeon, but I haven't noticed.)
2285                          */
2286                         if (monst_spell_monst(m_idx)) return;
2287                 }
2288                 else
2289                 {
2290                         /* Attempt to do counter attack at first */
2291                         if (monst_spell_monst(m_idx)) return;
2292
2293                         if (aware && make_attack_spell(m_idx)) return;
2294                 }
2295         }
2296
2297         /* Hack -- Assume no movement */
2298         mm[0] = mm[1] = mm[2] = mm[3] = 0;
2299         mm[4] = mm[5] = mm[6] = mm[7] = 0;
2300
2301
2302         /* Confused -- 100% random */
2303         if (MON_CONFUSED(m_ptr) || !aware)
2304         {
2305                 /* Try four "random" directions */
2306                 mm[0] = mm[1] = mm[2] = mm[3] = 5;
2307         }
2308
2309         /* 75% random movement */
2310         else if (((r_ptr->flags1 & (RF1_RAND_50 | RF1_RAND_25)) == (RF1_RAND_50 | RF1_RAND_25)) &&
2311                  (randint0(100) < 75))
2312         {
2313                 /* Memorize flags */
2314                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags1 |= (RF1_RAND_50 | RF1_RAND_25);
2315
2316                 /* Try four "random" directions */
2317                 mm[0] = mm[1] = mm[2] = mm[3] = 5;
2318         }
2319
2320         /* 50% random movement */
2321         else if ((r_ptr->flags1 & RF1_RAND_50) &&
2322                                 (randint0(100) < 50))
2323         {
2324                 /* Memorize flags */
2325                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags1 |= (RF1_RAND_50);
2326
2327                 /* Try four "random" directions */
2328                 mm[0] = mm[1] = mm[2] = mm[3] = 5;
2329         }
2330
2331         /* 25% random movement */
2332         else if ((r_ptr->flags1 & RF1_RAND_25) &&
2333                                 (randint0(100) < 25))
2334         {
2335                 /* Memorize flags */
2336                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags1 |= RF1_RAND_25;
2337
2338                 /* Try four "random" directions */
2339                 mm[0] = mm[1] = mm[2] = mm[3] = 5;
2340         }
2341
2342         /* Can't reach player - find something else to hit */
2343         else if ((r_ptr->flags1 & RF1_NEVER_MOVE) && (m_ptr->cdis > 1))
2344         {
2345                 /* Try four "random" directions */
2346                 mm[0] = mm[1] = mm[2] = mm[3] = 5;
2347
2348                 /* Look for an enemy */
2349 #if 0  /* Hack - Too slow.  Mimic pits are horrible with this on. */
2350                 get_enemy_dir(m_idx, mm);
2351 #endif /* 0 */
2352         }
2353
2354         /* Pets will follow the player */
2355         else if (is_pet(m_ptr))
2356         {
2357                 /* Are we trying to avoid the player? */
2358                 bool avoid = ((p_ptr->pet_follow_distance < 0) && (m_ptr->cdis <= (0 - p_ptr->pet_follow_distance)));
2359
2360                 /* Do we want to find the player? */
2361                 bool lonely = (!avoid && (m_ptr->cdis > p_ptr->pet_follow_distance));
2362
2363                 /* Should we find the player if we can't find a monster? */
2364                 bool distant = (m_ptr->cdis > PET_SEEK_DIST);
2365
2366                 /* by default, move randomly */
2367                 mm[0] = mm[1] = mm[2] = mm[3] = 5;
2368
2369                 /* Look for an enemy */
2370                 if (!get_enemy_dir(m_idx, mm))
2371                 {
2372                         /* Find the player if necessary */
2373                         if (avoid || lonely || distant)
2374                         {
2375                                 /* Remember the leash length */
2376                                 POSITION dis = p_ptr->pet_follow_distance;
2377
2378                                 /* Hack -- adjust follow distance temporarily */
2379                                 if (p_ptr->pet_follow_distance > PET_SEEK_DIST)
2380                                 {
2381                                         p_ptr->pet_follow_distance = PET_SEEK_DIST;
2382                                 }
2383
2384                                 /* Find the player */
2385                                 (void)get_moves(m_idx, mm);
2386
2387                                 /* Restore the leash */
2388                                 p_ptr->pet_follow_distance = (s16b)dis;
2389                         }
2390                 }
2391         }
2392
2393         /* Friendly monster movement */
2394         else if (!is_hostile(m_ptr))
2395         {
2396                 /* by default, move randomly */
2397                 mm[0] = mm[1] = mm[2] = mm[3] = 5;
2398
2399                 /* Look for an enemy */
2400                 get_enemy_dir(m_idx, mm);
2401         }
2402         /* Normal movement */
2403         else
2404         {
2405                 /* Logical moves, may do nothing */
2406                 if (!get_moves(m_idx, mm)) return;
2407         }
2408
2409         /* Assume nothing */
2410         do_turn = FALSE;
2411         do_move = FALSE;
2412         do_view = FALSE;
2413         must_alter_to_move = FALSE;
2414
2415         /* Assume nothing */
2416         did_open_door = FALSE;
2417         did_bash_door = FALSE;
2418         did_take_item = FALSE;
2419         did_kill_item = FALSE;
2420         did_move_body = FALSE;
2421         did_pass_wall = FALSE;
2422         did_kill_wall = FALSE;
2423
2424         /* Take a zero-terminated array of "directions" */
2425         for (i = 0; mm[i]; i++)
2426         {
2427                 /* Get the direction */
2428                 d = mm[i];
2429
2430                 /* Hack -- allow "randomized" motion */
2431                 if (d == 5) d = ddd[randint0(8)];
2432
2433                 /* Get the destination */
2434                 ny = oy + ddy[d];
2435                 nx = ox + ddx[d];
2436
2437                 /* Ignore locations off of edge */
2438                 if (!in_bounds2(ny, nx)) continue;
2439
2440                 /* Access that grid */
2441                 g_ptr = &current_floor_ptr->grid_array[ny][nx];
2442                 f_ptr = &f_info[g_ptr->feat];
2443                 can_cross = monster_can_cross_terrain(g_ptr->feat, r_ptr, is_riding_mon ? CEM_RIDING : 0);
2444
2445                 /* Access that grid's contents */
2446                 y_ptr = &current_floor_ptr->m_list[g_ptr->m_idx];
2447
2448                 /* Hack -- player 'in' wall */
2449                 if (player_bold(ny, nx))
2450                 {
2451                         do_move = TRUE;
2452                 }
2453
2454                 /* Possibly a monster to attack */
2455                 else if (g_ptr->m_idx)
2456                 {
2457                         do_move = TRUE;
2458                 }
2459
2460                 /* Monster destroys walls (and doors) */
2461                 else if ((r_ptr->flags2 & RF2_KILL_WALL) &&
2462                          (can_cross ? !have_flag(f_ptr->flags, FF_LOS) : !is_riding_mon) &&
2463                          have_flag(f_ptr->flags, FF_HURT_DISI) && !have_flag(f_ptr->flags, FF_PERMANENT) &&
2464                          check_hp_for_feat_destruction(f_ptr, m_ptr))
2465                 {
2466                         /* Eat through walls/doors/rubble */
2467                         do_move = TRUE;
2468                         if (!can_cross) must_alter_to_move = TRUE;
2469
2470                         /* Monster destroyed a wall (later) */
2471                         did_kill_wall = TRUE;
2472                 }
2473
2474                 /* Floor is open? */
2475                 else if (can_cross)
2476                 {
2477                         /* Go ahead and move */
2478                         do_move = TRUE;
2479
2480                         /* Monster moves through walls (and doors) */
2481                         if ((r_ptr->flags2 & RF2_PASS_WALL) && (!is_riding_mon || p_ptr->pass_wall) &&
2482                             have_flag(f_ptr->flags, FF_CAN_PASS))
2483                         {
2484                                 /* Monster went through a wall */
2485                                 did_pass_wall = TRUE;
2486                         }
2487                 }
2488
2489                 /* Handle doors and secret doors */
2490                 else if (is_closed_door(g_ptr->feat))
2491                 {
2492                         bool may_bash = TRUE;
2493
2494                         /* Assume no move allowed */
2495                         do_move = FALSE;
2496
2497                         /* Creature can open doors. */
2498                         if ((r_ptr->flags2 & RF2_OPEN_DOOR) && have_flag(f_ptr->flags, FF_OPEN) &&
2499                                  (!is_pet(m_ptr) || (p_ptr->pet_extra_flags & PF_OPEN_DOORS)))
2500                         {
2501                                 /* Closed doors */
2502                                 if (!f_ptr->power)
2503                                 {
2504                                         /* The door is open */
2505                                         did_open_door = TRUE;
2506
2507                                         /* Do not bash the door */
2508                                         may_bash = FALSE;
2509
2510                                         do_turn = TRUE;
2511                                 }
2512
2513                                 /* Locked doors (not jammed) */
2514                                 else
2515                                 {
2516                                         /* Try to unlock it */
2517                                         if (randint0(m_ptr->hp / 10) > f_ptr->power)
2518                                         {
2519                                                 /* Unlock the door */
2520                                                 cave_alter_feat(ny, nx, FF_DISARM);
2521
2522                                                 /* Do not bash the door */
2523                                                 may_bash = FALSE;
2524
2525                                                 do_turn = TRUE;
2526                                         }
2527                                 }
2528                         }
2529
2530                         /* Stuck doors -- attempt to bash them down if allowed */
2531                         if (may_bash && (r_ptr->flags2 & RF2_BASH_DOOR) && have_flag(f_ptr->flags, FF_BASH) &&
2532                                 (!is_pet(m_ptr) || (p_ptr->pet_extra_flags & PF_OPEN_DOORS)))
2533                         {
2534                                 /* Attempt to Bash */
2535                                 if (check_hp_for_feat_destruction(f_ptr, m_ptr) && (randint0(m_ptr->hp / 10) > f_ptr->power))
2536                                 {
2537                                         if (have_flag(f_ptr->flags, FF_GLASS))
2538                                                 msg_print(_("ガラスが砕ける音がした！", "You hear a glass was crashed!"));
2539                                         else
2540                                                 msg_print(_("ドアを叩き開ける音がした！", "You hear a door burst open!"));
2541
2542                                         /* Disturb (sometimes) */
2543                                         if (disturb_minor) disturb(FALSE, FALSE);
2544
2545                                         /* The door was bashed open */
2546                                         did_bash_door = TRUE;
2547
2548                                         /* Hack -- fall into doorway */
2549                                         do_move = TRUE;
2550                                         must_alter_to_move = TRUE;
2551                                 }
2552                         }
2553
2554
2555                         /* Deal with doors in the way */
2556                         if (did_open_door || did_bash_door)
2557                         {
2558                                 /* Break down the door */
2559                                 if (did_bash_door && ((randint0(100) < 50) || (feat_state(g_ptr->feat, FF_OPEN) == g_ptr->feat) || have_flag(f_ptr->flags, FF_GLASS)))
2560                                 {
2561                                         cave_alter_feat(ny, nx, FF_BASH);
2562
2563                                         if (!monster_is_valid(m_ptr)) /* Killed by shards of glass, etc. */
2564                                         {
2565                                                 p_ptr->update |= (PU_FLOW);
2566                                                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
2567                                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= (RF2_BASH_DOOR);
2568
2569                                                 return;
2570                                         }
2571                                 }
2572
2573                                 /* Open the door */
2574                                 else
2575                                 {
2576                                         cave_alter_feat(ny, nx, FF_OPEN);
2577                                 }
2578
2579                                 f_ptr = &f_info[g_ptr->feat];
2580
2581                                 /* Handle viewable doors */
2582                                 do_view = TRUE;
2583                         }
2584                 }
2585
2586                 /* Hack -- check for Glyph of Warding */
2587                 if (do_move && is_glyph_grid(g_ptr) &&
2588                     !((r_ptr->flags1 & RF1_NEVER_BLOW) && player_bold(ny, nx)))
2589                 {
2590                         /* Assume no move allowed */
2591                         do_move = FALSE;
2592
2593                         /* Break the ward */
2594                         if (!is_pet(m_ptr) && (randint1(BREAK_GLYPH) < r_ptr->level))
2595                         {
2596                                 /* Describe observable breakage */
2597                                 if (g_ptr->info & CAVE_MARK)
2598                                 {
2599                                         msg_print(_("守りのルーンが壊れた！", "The rune of protection is broken!"));
2600                                 }
2601
2602                                 /* Forget the rune */
2603                                 g_ptr->info &= ~(CAVE_MARK);
2604
2605                                 /* Break the rune */
2606                                 g_ptr->info &= ~(CAVE_OBJECT);
2607                                 g_ptr->mimic = 0;
2608
2609                                 /* Allow movement */
2610                                 do_move = TRUE;
2611
2612                                 note_spot(ny, nx);
2613                         }
2614                 }
2615                 else if (do_move && is_explosive_rune_grid(g_ptr) &&
2616                          !((r_ptr->flags1 & RF1_NEVER_BLOW) && player_bold(ny, nx)))
2617                 {
2618                         /* Assume no move allowed */
2619                         do_move = FALSE;
2620
2621                         /* Break the ward */
2622                         if (!is_pet(m_ptr))
2623                         {
2624                                 /* Break the ward */
2625                                 if (randint1(BREAK_MINOR_GLYPH) > r_ptr->level)
2626                                 {
2627                                         /* Describe observable breakage */
2628                                         if (g_ptr->info & CAVE_MARK)
2629                                         {
2630                                                 msg_print(_("ルーンが爆発した！", "The rune explodes!"));
2631                                                 project(0, 2, ny, nx, 2 * (p_ptr->lev + damroll(7, 7)), GF_MANA, (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI), -1);
2632                                         }
2633                                 }
2634                                 else
2635                                 {
2636                                         msg_print(_("爆発のルーンは解除された。", "An explosive rune was disarmed."));
2637                                 }
2638
2639                                 /* Forget the rune */
2640                                 g_ptr->info &= ~(CAVE_MARK);
2641
2642                                 /* Break the rune */
2643                                 g_ptr->info &= ~(CAVE_OBJECT);
2644                                 g_ptr->mimic = 0;
2645
2646                                 note_spot(ny, nx);
2647                                 lite_spot(ny, nx);
2648
2649                                 if (!monster_is_valid(m_ptr)) return;
2650                                 /* Allow movement */
2651                                 do_move = TRUE;
2652                         }
2653                 }
2654
2655                 /* The player is in the way */
2656                 if (do_move && player_bold(ny, nx))
2657                 {
2658                         /* Some monsters never attack */
2659                         if (r_ptr->flags1 & RF1_NEVER_BLOW)
2660                         {
2661                                 /* Hack -- memorize lack of attacks */
2662                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags1 |= (RF1_NEVER_BLOW);
2663
2664                                 /* Do not move */
2665                                 do_move = FALSE;
2666                         }
2667
2668                         /* In anti-melee dungeon, stupid or confused monster takes useless current_world_ptr->game_turn */
2669                         if (do_move && (d_info[p_ptr->dungeon_idx].flags1 & DF1_NO_MELEE))
2670                         {
2671                                 if (!MON_CONFUSED(m_ptr))
2672                                 {
2673                                         if (!(r_ptr->flags2 & RF2_STUPID)) do_move = FALSE;
2674                                         else
2675                                         {
2676                                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= (RF2_STUPID);
2677                                         }
2678                                 }
2679                         }
2680
2681                         /* The player is in the way.  Attack him. */
2682                         if (do_move)
2683                         {
2684                                 if (!p_ptr->riding || one_in_(2))
2685                                 {
2686                                         /* Do the attack */
2687                                         (void)make_attack_normal(m_idx);
2688
2689                                         /* Do not move */
2690                                         do_move = FALSE;
2691
2692                                         /* Took a current_world_ptr->game_turn */
2693                                         do_turn = TRUE;
2694                                 }
2695                         }
2696                 }
2697
2698                 /* A monster is in the way */
2699                 if (do_move && g_ptr->m_idx)
2700                 {
2701                         monster_race *z_ptr = &r_info[y_ptr->r_idx];
2702
2703                         /* Assume no movement */
2704                         do_move = FALSE;
2705
2706                         /* Attack 'enemies' */
2707                         if (((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW) &&
2708                                  (r_ptr->mexp * r_ptr->level > z_ptr->mexp * z_ptr->level) &&
2709                                  can_cross && (g_ptr->m_idx != p_ptr->riding)) ||
2710                                 are_enemies(m_ptr, y_ptr) || MON_CONFUSED(m_ptr))
2711                         {
2712                                 if (!(r_ptr->flags1 & RF1_NEVER_BLOW))
2713                                 {
2714                                         if (r_ptr->flags2 & RF2_KILL_BODY)
2715                                         {
2716                                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= (RF2_KILL_BODY);
2717                                         }
2718
2719                                         /* attack */
2720                                         if (y_ptr->r_idx && (y_ptr->hp >= 0))
2721                                         {
2722                                                 if (monst_attack_monst(m_idx, g_ptr->m_idx)) return;
2723
2724                                                 /* In anti-melee dungeon, stupid or confused monster takes useless current_world_ptr->game_turn */
2725                                                 else if (d_info[p_ptr->dungeon_idx].flags1 & DF1_NO_MELEE)
2726                                                 {
2727                                                         if (MON_CONFUSED(m_ptr)) return;
2728                                                         else if (r_ptr->flags2 & RF2_STUPID)
2729                                                         {
2730                                                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= (RF2_STUPID);
2731                                                                 return;
2732                                                         }
2733                                                 }
2734                                         }
2735                                 }
2736                         }
2737
2738                         /* Push past weaker monsters (unless leaving a wall) */
2739                         else if ((r_ptr->flags2 & RF2_MOVE_BODY) && !(r_ptr->flags1 & RF1_NEVER_MOVE) &&
2740                                 (r_ptr->mexp > z_ptr->mexp) &&
2741                                 can_cross && (g_ptr->m_idx != p_ptr->riding) &&
2742                                 monster_can_cross_terrain(current_floor_ptr->grid_array[m_ptr->fy][m_ptr->fx].feat, z_ptr, 0))
2743                         {
2744                                 /* Allow movement */
2745                                 do_move = TRUE;
2746
2747                                 /* Monster pushed past another monster */
2748                                 did_move_body = TRUE;
2749
2750                                 /* Wake up the moved monster */
2751                                 (void)set_monster_csleep(g_ptr->m_idx, 0);
2752
2753                                 /* Message */
2754                         }
2755                 }
2756
2757                 if (is_riding_mon)
2758                 {
2759                         if (!p_ptr->riding_ryoute && !MON_MONFEAR(&current_floor_ptr->m_list[p_ptr->riding])) do_move = FALSE;
2760                 }
2761
2762                 if (did_kill_wall && do_move)
2763                 {
2764                         if (one_in_(GRINDNOISE))
2765                         {
2766                                 if (have_flag(f_ptr->flags, FF_GLASS))
2767                                         msg_print(_("何かの砕ける音が聞こえる。", "There is a crashing sound."));
2768                                 else
2769                                         msg_print(_("ギシギシいう音が聞こえる。", "There is a grinding sound."));
2770                         }
2771
2772                         cave_alter_feat(ny, nx, FF_HURT_DISI);
2773
2774                         if (!monster_is_valid(m_ptr)) /* Killed by shards of glass, etc. */
2775                         {
2776                                 p_ptr->update |= (PU_FLOW);
2777                                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
2778                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= (RF2_KILL_WALL);
2779
2780                                 return;
2781                         }
2782
2783                         f_ptr = &f_info[g_ptr->feat];
2784
2785                         /* Note changes to viewable region */
2786                         do_view = TRUE;
2787                         do_turn = TRUE;
2788                 }
2789
2790                 if (must_alter_to_move && (r_ptr->flags7 & RF7_AQUATIC))
2791                 {
2792                         if (!monster_can_cross_terrain(g_ptr->feat, r_ptr, is_riding_mon ? CEM_RIDING : 0))
2793                         {
2794                                 /* Assume no move allowed */
2795                                 do_move = FALSE;
2796                         }
2797                 }
2798
2799                 /*
2800                  * Check if monster can cross terrain
2801                  * This is checked after the normal attacks
2802                  * to allow monsters to attack an enemy,
2803                  * even if it can't enter the terrain.
2804                  */
2805                 if (do_move && !can_cross && !did_kill_wall && !did_bash_door)
2806                 {
2807                         /* Assume no move allowed */
2808                         do_move = FALSE;
2809                 }
2810
2811                 /* Some monsters never move */
2812                 if (do_move && (r_ptr->flags1 & RF1_NEVER_MOVE))
2813                 {
2814                         /* Hack -- memorize lack of moves */
2815                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags1 |= (RF1_NEVER_MOVE);
2816
2817                         /* Do not move */
2818                         do_move = FALSE;
2819                 }
2820
2821                 /* Creature has been allowed move */
2822                 if (do_move)
2823                 {
2824                         do_turn = TRUE;
2825
2826                         if (have_flag(f_ptr->flags, FF_TREE))
2827                         {
2828                                 if (!(r_ptr->flags7 & RF7_CAN_FLY) && !(r_ptr->flags8 & RF8_WILD_WOOD))
2829                                 {
2830                                         m_ptr->energy_need += ENERGY_NEED();
2831                                 }
2832                         }
2833
2834                         if (!is_riding_mon)
2835                         {
2836                                 /* Hack -- Update the old location */
2837                                 current_floor_ptr->grid_array[oy][ox].m_idx = g_ptr->m_idx;
2838
2839                                 /* Mega-Hack -- move the old monster, if any */
2840                                 if (g_ptr->m_idx)
2841                                 {
2842                                         /* Move the old monster */
2843                                         y_ptr->fy = oy;
2844                                         y_ptr->fx = ox;
2845
2846                                         /* Update the old monster */
2847                                         update_monster(g_ptr->m_idx, TRUE);
2848                                 }
2849
2850                                 /* Hack -- Update the new location */
2851                                 g_ptr->m_idx = m_idx;
2852
2853                                 /* Move the monster */
2854                                 m_ptr->fy = ny;
2855                                 m_ptr->fx = nx;
2856                                 update_monster(m_idx, TRUE);
2857
2858                                 lite_spot(oy, ox);
2859                                 lite_spot(ny, nx);
2860                         }
2861                         else
2862                         {
2863                                 /* sound(SOUND_WALK); */
2864                                 if (!move_player_effect(ny, nx, MPE_DONT_PICKUP)) break;
2865                         }
2866
2867                         /* Possible disturb */
2868                         if (m_ptr->ml &&
2869                             (disturb_move ||
2870                              (disturb_near && (m_ptr->mflag & MFLAG_VIEW) && projectable(p_ptr->y, p_ptr->x, m_ptr->fy, m_ptr->fx)) ||
2871                              (disturb_high && ap_r_ptr->r_tkills && ap_r_ptr->level >= p_ptr->lev)))
2872                         {
2873                                 if (is_hostile(m_ptr))
2874                                         disturb(FALSE, TRUE);
2875                         }
2876
2877                         /* Take or Kill objects on the floor */
2878                         if (g_ptr->o_idx && (r_ptr->flags2 & (RF2_TAKE_ITEM | RF2_KILL_ITEM)) &&
2879                             (!is_pet(m_ptr) || ((p_ptr->pet_extra_flags & PF_PICKUP_ITEMS) && (r_ptr->flags2 & RF2_TAKE_ITEM))))
2880                         {
2881                                 OBJECT_IDX this_o_idx, next_o_idx;
2882                                 bool do_take = (r_ptr->flags2 & RF2_TAKE_ITEM) ? TRUE : FALSE;
2883
2884                                 /* Scan all objects in the grid */
2885                                 for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
2886                                 {
2887                                         BIT_FLAGS flgs[TR_FLAG_SIZE], flg2 = 0L, flg3 = 0L, flgr = 0L;
2888                                         GAME_TEXT m_name[MAX_NLEN], o_name[MAX_NLEN];
2889                                         object_type *o_ptr = &current_floor_ptr->o_list[this_o_idx];
2890                                         next_o_idx = o_ptr->next_o_idx;
2891
2892                                         if (do_take)
2893                                         {
2894                                                 /* Skip gold */
2895                                                 if (o_ptr->tval == TV_GOLD) continue;
2896
2897                                                 /*
2898                                                  * Skip "real" corpses and statues, to avoid extreme
2899                                                  * silliness like a novice rogue pockets full of statues
2900                                                  * and corpses.
2901                                                  */
2902                                                 if ((o_ptr->tval == TV_CORPSE) ||
2903                                                     (o_ptr->tval == TV_STATUE)) continue;
2904                                         }
2905
2906                                         /* Extract some flags */
2907                                         object_flags(o_ptr, flgs);
2908
2909                                         /* Acquire the object name */
2910                                         object_desc(o_name, o_ptr, 0);
2911                                         monster_desc(m_name, m_ptr, MD_INDEF_HIDDEN);
2912
2913                                         /* React to objects that hurt the monster */
2914                                         if (have_flag(flgs, TR_SLAY_DRAGON)) flg3 |= (RF3_DRAGON);
2915                                         if (have_flag(flgs, TR_KILL_DRAGON)) flg3 |= (RF3_DRAGON);
2916                                         if (have_flag(flgs, TR_SLAY_TROLL))  flg3 |= (RF3_TROLL);
2917                                         if (have_flag(flgs, TR_KILL_TROLL))  flg3 |= (RF3_TROLL);
2918                                         if (have_flag(flgs, TR_SLAY_GIANT))  flg3 |= (RF3_GIANT);
2919                                         if (have_flag(flgs, TR_KILL_GIANT))  flg3 |= (RF3_GIANT);
2920                                         if (have_flag(flgs, TR_SLAY_ORC))    flg3 |= (RF3_ORC);
2921                                         if (have_flag(flgs, TR_KILL_ORC))    flg3 |= (RF3_ORC);
2922                                         if (have_flag(flgs, TR_SLAY_DEMON))  flg3 |= (RF3_DEMON);
2923                                         if (have_flag(flgs, TR_KILL_DEMON))  flg3 |= (RF3_DEMON);
2924                                         if (have_flag(flgs, TR_SLAY_UNDEAD)) flg3 |= (RF3_UNDEAD);
2925                                         if (have_flag(flgs, TR_KILL_UNDEAD)) flg3 |= (RF3_UNDEAD);
2926                                         if (have_flag(flgs, TR_SLAY_ANIMAL)) flg3 |= (RF3_ANIMAL);
2927                                         if (have_flag(flgs, TR_KILL_ANIMAL)) flg3 |= (RF3_ANIMAL);
2928                                         if (have_flag(flgs, TR_SLAY_EVIL))   flg3 |= (RF3_EVIL);
2929                                         if (have_flag(flgs, TR_KILL_EVIL))   flg3 |= (RF3_EVIL);
2930                                         if (have_flag(flgs, TR_SLAY_HUMAN))  flg2 |= (RF2_HUMAN);
2931                                         if (have_flag(flgs, TR_KILL_HUMAN))  flg2 |= (RF2_HUMAN);
2932                                         if (have_flag(flgs, TR_BRAND_ACID))  flgr |= (RFR_IM_ACID);
2933                                         if (have_flag(flgs, TR_BRAND_ELEC))  flgr |= (RFR_IM_ELEC);
2934                                         if (have_flag(flgs, TR_BRAND_FIRE))  flgr |= (RFR_IM_FIRE);
2935                                         if (have_flag(flgs, TR_BRAND_COLD))  flgr |= (RFR_IM_COLD);
2936                                         if (have_flag(flgs, TR_BRAND_POIS))  flgr |= (RFR_IM_POIS);
2937
2938                                         /* The object cannot be picked up by the monster */
2939                                         if (object_is_artifact(o_ptr) || (r_ptr->flags3 & flg3) || (r_ptr->flags2 & flg2) ||
2940                                             ((~(r_ptr->flagsr) & flgr) && !(r_ptr->flagsr & RFR_RES_ALL)))
2941                                         {
2942                                                 /* Only give a message for "take_item" */
2943                                                 if (do_take && (r_ptr->flags2 & RF2_STUPID))
2944                                                 {
2945                                                         did_take_item = TRUE;
2946
2947                                                         /* Describe observable situations */
2948                                                         if (m_ptr->ml && player_can_see_bold(ny, nx))
2949                                                         {
2950                                                                 msg_format(_("%^sは%sを拾おうとしたが、だめだった。", "%^s tries to pick up %s, but fails."), m_name, o_name);
2951                                                         }
2952                                                 }
2953                                         }
2954
2955                                         /* Pick up the item */
2956                                         else if (do_take)
2957                                         {
2958                                                 did_take_item = TRUE;
2959
2960                                                 /* Describe observable situations */
2961                                                 if (player_can_see_bold(ny, nx))
2962                                                 {
2963                                                         msg_format(_("%^sが%sを拾った。", "%^s picks up %s."), m_name, o_name);
2964                                                 }
2965
2966                                                 /* Excise the object */
2967                                                 excise_object_idx(this_o_idx);
2968
2969                                                 /* Forget mark */
2970                                                 o_ptr->marked &= OM_TOUCHED;
2971
2972                                                 /* Forget location */
2973                                                 o_ptr->iy = o_ptr->ix = 0;
2974
2975                                                 /* Memorize monster */
2976                                                 o_ptr->held_m_idx = m_idx;
2977
2978                                                 /* Build a stack */
2979                                                 o_ptr->next_o_idx = m_ptr->hold_o_idx;
2980
2981                                                 /* Carry object */
2982                                                 m_ptr->hold_o_idx = this_o_idx;
2983                                         }
2984
2985                                         /* Destroy the item if not a pet */
2986                                         else if (!is_pet(m_ptr))
2987                                         {
2988                                                 did_kill_item = TRUE;
2989
2990                                                 /* Describe observable situations */
2991                                                 if (player_has_los_bold(ny, nx))
2992                                                 {
2993                                                         msg_format(_("%^sが%sを破壊した。", "%^s destroys %s."), m_name, o_name);
2994                                                 }
2995
2996                                                 delete_object_idx(this_o_idx);
2997                                         }
2998                                 }
2999                         }
3000                 }
3001
3002                 /* Stop when done */
3003                 if (do_turn) break;
3004         }
3005
3006         /*
3007          *  Forward movements failed, but now received LOS attack!
3008          *  Try to flow by smell.
3009          */
3010         if (p_ptr->no_flowed && i > 2 &&  m_ptr->target_y)
3011                 m_ptr->mflag2 &= ~MFLAG2_NOFLOW;
3012
3013         /* If we haven't done anything, try casting a spell again */
3014         if (!do_turn && !do_move && !MON_MONFEAR(m_ptr) && !is_riding_mon && aware)
3015         {
3016                 /* Try to cast spell again */
3017                 if (r_ptr->freq_spell && randint1(100) <= r_ptr->freq_spell)
3018                 {
3019                         if (make_attack_spell(m_idx)) return;
3020                 }
3021         }
3022
3023
3024         /* Notice changes in view */
3025         if (do_view)
3026         {
3027                 p_ptr->update |= (PU_FLOW);
3028                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
3029         }
3030
3031         /* Notice changes in view */
3032         if (do_move && ((r_ptr->flags7 & (RF7_SELF_LD_MASK | RF7_HAS_DARK_1 | RF7_HAS_DARK_2))
3033                 || ((r_ptr->flags7 & (RF7_HAS_LITE_1 | RF7_HAS_LITE_2)) && !p_ptr->inside_battle)))
3034         {
3035                 p_ptr->update |= (PU_MON_LITE);
3036         }
3037
3038         /* Learn things from observable monster */
3039         if (is_original_ap_and_seen(m_ptr))
3040         {
3041                 /* Monster opened a door */
3042                 if (did_open_door) r_ptr->r_flags2 |= (RF2_OPEN_DOOR);
3043
3044                 /* Monster bashed a door */
3045                 if (did_bash_door) r_ptr->r_flags2 |= (RF2_BASH_DOOR);
3046
3047                 /* Monster tried to pick something up */
3048                 if (did_take_item) r_ptr->r_flags2 |= (RF2_TAKE_ITEM);
3049
3050                 /* Monster tried to crush something */
3051                 if (did_kill_item) r_ptr->r_flags2 |= (RF2_KILL_ITEM);
3052
3053                 /* Monster pushed past another monster */
3054                 if (did_move_body) r_ptr->r_flags2 |= (RF2_MOVE_BODY);
3055
3056                 /* Monster passed through a wall */
3057                 if (did_pass_wall) r_ptr->r_flags2 |= (RF2_PASS_WALL);
3058
3059                 /* Monster destroyed a wall */
3060                 if (did_kill_wall) r_ptr->r_flags2 |= (RF2_KILL_WALL);
3061         }
3062
3063
3064         /* Hack -- get "bold" if out of options */
3065         if (!do_turn && !do_move && MON_MONFEAR(m_ptr) && aware)
3066         {
3067                 /* No longer afraid */
3068                 (void)set_monster_monfear(m_idx, 0);
3069
3070                 /* Message if seen */
3071                 if (see_m)
3072                 {
3073                         GAME_TEXT m_name[MAX_NLEN];
3074                         monster_desc(m_name, m_ptr, 0);
3075                         msg_format(_("%^sは戦いを決意した！", "%^s turns to fight!"), m_name);
3076                 }
3077
3078                 if (m_ptr->ml) chg_virtue(V_COMPASSION, -1);
3079
3080                 /* Actually do something now (?) */
3081         }
3082 }
3083
3084 /*!
3085  * @brief 全モンスターのターン管理メインルーチン /
3086  * Process all the "live" monsters, once per game current_world_ptr->game_turn.
3087  * @return なし
3088  * @details
3089  * During each game current_world_ptr->game_turn, we scan through the list of all the "live" monsters,\n
3090  * (backwards, so we can excise any "freshly dead" monsters), energizing each\n
3091  * monster, and allowing fully energized monsters to move, attack, pass, etc.\n
3092  *\n
3093  * Note that monsters can never move in the monster array (except when the\n
3094  * "compact_monsters()" function is called by "dungeon()" or "save_player()").\n
3095  *\n
3096  * This function is responsible for at least half of the processor time\n
3097  * on a normal system with a "normal" amount of monsters and a player doing\n
3098  * normal things.\n
3099  *\n
3100  * When the player is resting, virtually 90% of the processor time is spent\n
3101  * in this function, and its children, "process_monster()" and "make_move()".\n
3102  *\n
3103  * Most of the rest of the time is spent in "update_view()" and "lite_spot()",\n
3104  * especially when the player is running.\n
3105  *\n
3106  * Note the special "MFLAG_BORN" flag, which allows us to ignore "fresh"\n
3107  * monsters while they are still being "born".  A monster is "fresh" only\n
3108  * during the current_world_ptr->game_turn in which it is created, and we use the "hack_m_idx" to\n
3109  * determine if the monster is yet to be processed during the current current_world_ptr->game_turn.\n
3110  *\n
3111  * Note the special "MFLAG_NICE" flag, which allows the player to get one\n
3112  * move before any "nasty" monsters get to use their spell attacks.\n
3113  *\n
3114  * Note that when the "knowledge" about the currently tracked monster\n
3115  * changes (flags, attacks, spells), we induce a redraw of the monster\n
3116  * recall window.\n
3117  */
3118 void process_monsters(void)
3119 {
3120         MONSTER_IDX i;
3121         POSITION fx, fy;
3122
3123         bool            test;
3124
3125         monster_type    *m_ptr;
3126         monster_race    *r_ptr;
3127
3128         MONRACE_IDX old_monster_race_idx;
3129
3130         BIT_FLAGS old_r_flags1 = 0L;
3131         BIT_FLAGS old_r_flags2 = 0L;
3132         BIT_FLAGS old_r_flags3 = 0L;
3133         BIT_FLAGS old_r_flags4 = 0L;
3134         BIT_FLAGS old_r_flags5 = 0L;
3135         BIT_FLAGS old_r_flags6 = 0L;
3136         BIT_FLAGS old_r_flagsr = 0L;
3137
3138         byte old_r_blows0 = 0;
3139         byte old_r_blows1 = 0;
3140         byte old_r_blows2 = 0;
3141         byte old_r_blows3 = 0;
3142
3143         byte old_r_cast_spell = 0;
3144
3145         SPEED speed;
3146
3147         /* Clear monster fighting indicator */
3148         mon_fight = FALSE;
3149
3150         /* Memorize old race */
3151         old_monster_race_idx = p_ptr->monster_race_idx;
3152
3153         /* Acquire knowledge */
3154         if (p_ptr->monster_race_idx)
3155         {
3156                 /* Acquire current monster */
3157                 r_ptr = &r_info[p_ptr->monster_race_idx];
3158
3159                 /* Memorize flags */
3160                 old_r_flags1 = r_ptr->r_flags1;
3161                 old_r_flags2 = r_ptr->r_flags2;
3162                 old_r_flags3 = r_ptr->r_flags3;
3163                 old_r_flags4 = r_ptr->r_flags4;
3164                 old_r_flags5 = r_ptr->r_flags5;
3165                 old_r_flags6 = r_ptr->r_flags6;
3166                 old_r_flagsr = r_ptr->r_flagsr;
3167
3168                 /* Memorize blows */
3169                 old_r_blows0 = r_ptr->r_blows[0];
3170                 old_r_blows1 = r_ptr->r_blows[1];
3171                 old_r_blows2 = r_ptr->r_blows[2];
3172                 old_r_blows3 = r_ptr->r_blows[3];
3173
3174                 /* Memorize castings */
3175                 old_r_cast_spell = r_ptr->r_cast_spell;
3176         }
3177
3178
3179         /* Process the monsters (backwards) */
3180         for (i = current_floor_ptr->m_max - 1; i >= 1; i--)
3181         {
3182                 /* Access the monster */
3183                 m_ptr = &current_floor_ptr->m_list[i];
3184                 r_ptr = &r_info[m_ptr->r_idx];
3185
3186                 /* Handle "leaving" */
3187                 if (p_ptr->leaving) break;
3188
3189                 /* Ignore "dead" monsters */
3190                 if (!monster_is_valid(m_ptr)) continue;
3191
3192                 if (p_ptr->wild_mode) continue;
3193
3194
3195                 /* Handle "fresh" monsters */
3196                 if (m_ptr->mflag & MFLAG_BORN)
3197                 {
3198                         /* No longer "fresh" */
3199                         m_ptr->mflag &= ~(MFLAG_BORN);
3200
3201                         /* Skip */
3202                         continue;
3203                 }
3204
3205                 /* Hack -- Require proximity */
3206                 if (m_ptr->cdis >= AAF_LIMIT) continue;
3207
3208                 fx = m_ptr->fx;
3209                 fy = m_ptr->fy;
3210
3211                 /* Flow by smell is allowed */
3212                 if (!p_ptr->no_flowed)
3213                 {
3214                         m_ptr->mflag2 &= ~MFLAG2_NOFLOW;
3215                 }
3216
3217                 /* Assume no move */
3218                 test = FALSE;
3219
3220                 /* Handle "sensing radius" */
3221                 if (m_ptr->cdis <= (is_pet(m_ptr) ? (r_ptr->aaf > MAX_SIGHT ? MAX_SIGHT : r_ptr->aaf) : r_ptr->aaf))
3222                 {
3223                         /* We can "sense" the player */
3224                         test = TRUE;
3225                 }
3226
3227                 /* Handle "sight" and "aggravation" */
3228         else if ((m_ptr->cdis <= MAX_SIGHT || p_ptr->inside_battle) &&
3229                         (player_has_los_bold(fy, fx) || (p_ptr->cursed & TRC_AGGRAVATE)))
3230                 {
3231                         /* We can "see" or "feel" the player */
3232                         test = TRUE;
3233                 }
3234
3235 #if 0 /* (current_floor_ptr->grid_array[p_ptr->y][p_ptr->x].when == current_floor_ptr->grid_array[fy][fx].when) is always FALSE... */
3236                 /* Hack -- Monsters can "smell" the player from far away */
3237                 /* Note that most monsters have "aaf" of "20" or so */
3238                 else if (!(m_ptr->mflag2 & MFLAG2_NOFLOW) &&
3239                         cave_have_flag_bold(p_ptr->y, p_ptr->x, FF_MOVE) &&
3240                         (current_floor_ptr->grid_array[p_ptr->y][p_ptr->x].when == current_floor_ptr->grid_array[fy][fx].when) &&
3241                         (current_floor_ptr->grid_array[fy][fx].dist < MONSTER_FLOW_DEPTH) &&
3242                         (current_floor_ptr->grid_array[fy][fx].dist < r_ptr->aaf))
3243                 {
3244                         /* We can "smell" the player */
3245                         test = TRUE;
3246                 }
3247 #endif
3248                 else if (m_ptr->target_y) test = TRUE;
3249
3250                 /* Do nothing */
3251                 if (!test) continue;
3252
3253
3254                 if (p_ptr->riding == i)
3255                         speed = p_ptr->pspeed;
3256                 else
3257                 {
3258                         speed = m_ptr->mspeed;
3259
3260                         /* Monsters move quickly in Nightmare mode */
3261                         if (ironman_nightmare) speed += 5;
3262
3263                         if (MON_FAST(m_ptr)) speed += 10;
3264                         if (MON_SLOW(m_ptr)) speed -= 10;
3265                 }
3266
3267                 /* Give this monster some energy */
3268                 m_ptr->energy_need -= SPEED_TO_ENERGY(speed);
3269
3270                 /* Not enough energy to move */
3271                 if (m_ptr->energy_need > 0) continue;
3272
3273                 /* Use up "some" energy */
3274                 m_ptr->energy_need += ENERGY_NEED();
3275
3276
3277                 /* Save global index */
3278                 hack_m_idx = i;
3279
3280                 /* Process the monster */
3281                 process_monster(i);
3282
3283                 reset_target(m_ptr);
3284
3285                 /* Give up flow_by_smell when it might useless */
3286                 if (p_ptr->no_flowed && one_in_(3))
3287                         m_ptr->mflag2 |= MFLAG2_NOFLOW;
3288
3289                 /* Hack -- notice death or departure */
3290                 if (!p_ptr->playing || p_ptr->is_dead) break;
3291
3292                 /* Notice leaving */
3293                 if (p_ptr->leaving) break;
3294         }
3295
3296         /* Reset global index */
3297         hack_m_idx = 0;
3298
3299
3300         /* Tracking a monster race (the same one we were before) */
3301         if (p_ptr->monster_race_idx && (p_ptr->monster_race_idx == old_monster_race_idx))
3302         {
3303                 /* Acquire monster race */
3304                 r_ptr = &r_info[p_ptr->monster_race_idx];
3305
3306                 /* Check for knowledge change */
3307                 if ((old_r_flags1 != r_ptr->r_flags1) ||
3308                         (old_r_flags2 != r_ptr->r_flags2) ||
3309                         (old_r_flags3 != r_ptr->r_flags3) ||
3310                         (old_r_flags4 != r_ptr->r_flags4) ||
3311                         (old_r_flags5 != r_ptr->r_flags5) ||
3312                         (old_r_flags6 != r_ptr->r_flags6) ||
3313                         (old_r_flagsr != r_ptr->r_flagsr) ||
3314                         (old_r_blows0 != r_ptr->r_blows[0]) ||
3315                         (old_r_blows1 != r_ptr->r_blows[1]) ||
3316                         (old_r_blows2 != r_ptr->r_blows[2]) ||
3317                         (old_r_blows3 != r_ptr->r_blows[3]) ||
3318                         (old_r_cast_spell != r_ptr->r_cast_spell))
3319                 {
3320                         p_ptr->window |= (PW_MONSTER);
3321                 }
3322         }
3323 }
3324