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