src/monster-floor/monster-sweep-grid.c

   1 /*!
   2  * @brief モンスターの移動方向を走査する処理
   3  * @date 2020/03/08
   4  * @author Hourier
   5  */
   6
   7 #include "monster-floor/monster-sweep-grid.h"
   8 #include "floor/cave.h"
   9 #include "floor/line-of-sight.h"
  10 #include "grid/feature.h"
  11 #include "grid/grid.h"
  12 #include "monster-race/monster-race.h"
  13 #include "monster-race/race-flags-ability1.h"
  14 #include "monster-race/race-flags-ability2.h"
  15 #include "monster-race/race-flags1.h"
  16 #include "monster-race/race-flags2.h"
  17 #include "monster-race/race-flags3.h"
  18 #include "monster-race/race-flags4.h"
  19 #include "monster/monster-flag-types.h"
  20 #include "monster/monster-info.h"
  21 #include "monster-floor/monster-safety-hiding.h"
  22 #include "monster/monster-status.h"
  23 #include "mspell/mspell-mask-definitions.h"
  24 #include "system/floor-type-definition.h"
  25 #include "target/projection-path-calculator.h"
  26
  27  /*!
  28   * @brief モンスターがプレイヤーから逃走するかどうかを返す /
  29   * Returns whether a given monster will try to run from the player.
  30   * @param m_idx 逃走するモンスターの参照ID
  31   * @return モンスターがプレイヤーから逃走するならばTRUEを返す。
  32   * @details
  33   * Monsters will attempt to avoid very powerful players.  See below.\n
  34   *\n
  35   * Because this function is called so often, little details are important\n
  36   * for efficiency.  Like not using "mod" or "div" when possible.  And\n
  37   * attempting to check the conditions in an optimal order.  Note that\n
  38   * "(x << 2) == (x * 4)" if "x" has enough bits to hold the result.\n
  39   *\n
  40   * Note that this function is responsible for about one to five percent\n
  41   * of the processor use in normal conditions...\n
  42   */
  43 static bool mon_will_run(player_type *target_ptr, MONSTER_IDX m_idx)
  44 {
  45         monster_type *m_ptr = &target_ptr->current_floor_ptr->m_list[m_idx];
  46         monster_race *r_ptr = &r_info[m_ptr->r_idx];
  47
  48         if (is_pet(m_ptr))
  49         {
  50                 return ((target_ptr->pet_follow_distance < 0) &&
  51                         (m_ptr->cdis <= (0 - target_ptr->pet_follow_distance)));
  52         }
  53
  54         if (m_ptr->cdis > MAX_SIGHT + 5) return FALSE;
  55         if (monster_fear_remaining(m_ptr)) return TRUE;
  56         if (m_ptr->cdis <= 5) return FALSE;
  57
  58         PLAYER_LEVEL p_lev = target_ptr->lev;
  59         DEPTH m_lev = r_ptr->level + (m_idx & 0x08) + 25;
  60         if (m_lev > p_lev + 4) return FALSE;
  61         if (m_lev + 4 <= p_lev) return TRUE;
  62
  63         HIT_POINT p_chp = target_ptr->chp;
  64         HIT_POINT p_mhp = target_ptr->mhp;
  65         HIT_POINT m_chp = m_ptr->hp;
  66         HIT_POINT m_mhp = m_ptr->maxhp;
  67         u32b p_val = (p_lev * p_mhp) + (p_chp << 2);
  68         u32b m_val = (m_lev * m_mhp) + (m_chp << 2);
  69         if (p_val * m_mhp > m_val * p_mhp) return TRUE;
  70
  71         return FALSE;
  72 }
  73
  74
  75 /*!
  76  * @brief モンスターがプレイヤーに向けて遠距離攻撃を行うことが可能なマスを走査する /
  77  * Search spell castable grid
  78  * @param target_ptr プレーヤーへの参照ポインタ
  79  * @param m_idx モンスターの参照ID
  80  * @param yp 適したマスのY座標を返す参照ポインタ
  81  * @param xp 適したマスのX座標を返す参照ポインタ
  82  * @return 有効なマスがあった場合TRUEを返す
  83  */
  84 static bool sweep_ranged_attack_grid(player_type *target_ptr, MONSTER_IDX m_idx, POSITION *yp, POSITION *xp)
  85 {
  86         floor_type *floor_ptr = target_ptr->current_floor_ptr;
  87         monster_type *m_ptr = &floor_ptr->m_list[m_idx];
  88         monster_race *r_ptr = &r_info[m_ptr->r_idx];
  89
  90         POSITION y1 = m_ptr->fy;
  91         POSITION x1 = m_ptr->fx;
  92
  93         if (projectable(target_ptr, y1, x1, target_ptr->y, target_ptr->x)) return FALSE;
  94
  95         int now_cost = floor_ptr->grid_array[y1][x1].cost;
  96         if (now_cost == 0) now_cost = 999;
  97
  98         bool can_open_door = FALSE;
  99         if (r_ptr->flags2 & (RF2_BASH_DOOR | RF2_OPEN_DOOR))
 100         {
 101                 can_open_door = TRUE;
 102         }
 103
 104         int best = 999;
 105         for (int i = 7; i >= 0; i--)
 106         {
 107                 POSITION y = y1 + ddy_ddd[i];
 108                 POSITION x = x1 + ddx_ddd[i];
 109                 if (!in_bounds2(floor_ptr, y, x)) continue;
 110                 if (player_bold(target_ptr, y, x)) return FALSE;
 111
 112                 grid_type *g_ptr;
 113                 g_ptr = &floor_ptr->grid_array[y][x];
 114                 int cost = g_ptr->cost;
 115                 if (!(((r_ptr->flags2 & RF2_PASS_WALL) && ((m_idx != target_ptr->riding) || target_ptr->pass_wall)) || ((r_ptr->flags2 & RF2_KILL_WALL) && (m_idx != target_ptr->riding))))
 116                 {
 117                         if (cost == 0) continue;
 118                         if (!can_open_door && is_closed_door(target_ptr, g_ptr->feat)) continue;
 119                 }
 120
 121                 if (cost == 0) cost = 998;
 122
 123                 if (now_cost < cost) continue;
 124                 if (!projectable(target_ptr, y, x, target_ptr->y, target_ptr->x)) continue;
 125                 if (best < cost) continue;
 126
 127                 best = cost;
 128                 *yp = y1 + ddy_ddd[i];
 129                 *xp = x1 + ddx_ddd[i];
 130         }
 131
 132         if (best == 999) return FALSE;
 133
 134         return TRUE;
 135 }
 136
 137
 138 /*!
 139  * @brief モンスターがプレイヤーに向けて接近することが可能なマスを走査する /
 140  * Choose the "best" direction for "flowing"
 141  * @param m_idx モンスターの参照ID
 142  * @param yp 移動先のマスのY座標を返す参照ポインタ
 143  * @param xp 移動先のマスのX座標を返す参照ポインタ
 144  * @param no_flow モンスターにFLOWフラグが経っていない状態でTRUE
 145  * @return なし
 146  * @details
 147  * Note that ghosts and rock-eaters are never allowed to "flow",\n
 148  * since they should move directly towards the player.\n
 149  *\n
 150  * Prefer "non-diagonal" directions, but twiddle them a little\n
 151  * to angle slightly towards the player's actual location.\n
 152  *\n
 153  * Allow very perceptive monsters to track old "spoor" left by\n
 154  * previous locations occupied by the player.  This will tend\n
 155  * to have monsters end up either near the player or on a grid\n
 156  * recently occupied by the player (and left via "teleport").\n
 157  *\n
 158  * Note that if "smell" is turned on, all monsters get vicious.\n
 159  *\n
 160  * Also note that teleporting away from a location will cause\n
 161  * the monsters who were chasing you to converge on that location\n
 162  * as long as you are still near enough to "annoy" them without\n
 163  * being close enough to chase directly.  I have no idea what will\n
 164  * happen if you combine "smell" with low "aaf" values.\n
 165  */
 166 static void sweep_movable_grid(player_type *target_ptr, MONSTER_IDX m_idx, POSITION *yp, POSITION *xp, bool no_flow)
 167 {
 168         grid_type *g_ptr;
 169         floor_type *floor_ptr = target_ptr->current_floor_ptr;
 170         monster_type *m_ptr = &floor_ptr->m_list[m_idx];
 171         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 172
 173         if (r_ptr->flags4 & (RF4_ATTACK_MASK) ||
 174                 r_ptr->a_ability_flags1 & (RF5_ATTACK_MASK) ||
 175                 r_ptr->a_ability_flags2 & (RF6_ATTACK_MASK))
 176         {
 177                 if (sweep_ranged_attack_grid(target_ptr, m_idx, yp, xp)) return;
 178         }
 179
 180         if (no_flow) return;
 181         if ((r_ptr->flags2 & RF2_PASS_WALL) && ((m_idx != target_ptr->riding) || target_ptr->pass_wall)) return;
 182         if ((r_ptr->flags2 & RF2_KILL_WALL) && (m_idx != target_ptr->riding)) return;
 183
 184         POSITION y1 = m_ptr->fy;
 185         POSITION x1 = m_ptr->fx;
 186         if (player_has_los_bold(target_ptr, y1, x1) && projectable(target_ptr, target_ptr->y, target_ptr->x, y1, x1)) return;
 187
 188         g_ptr = &floor_ptr->grid_array[y1][x1];
 189
 190         int best;
 191         bool use_scent = FALSE;
 192         if (g_ptr->cost)
 193         {
 194                 best = 999;
 195         }
 196         else if (g_ptr->when)
 197         {
 198                 if (floor_ptr->grid_array[target_ptr->y][target_ptr->x].when - g_ptr->when > 127) return;
 199
 200                 use_scent = TRUE;
 201                 best = 0;
 202         }
 203         else
 204         {
 205                 return;
 206         }
 207
 208         for (int i = 7; i >= 0; i--)
 209         {
 210                 POSITION y = y1 + ddy_ddd[i];
 211                 POSITION x = x1 + ddx_ddd[i];
 212
 213                 if (!in_bounds2(floor_ptr, y, x)) continue;
 214
 215                 g_ptr = &floor_ptr->grid_array[y][x];
 216                 if (use_scent)
 217                 {
 218                         int when = g_ptr->when;
 219                         if (best > when) continue;
 220
 221                         best = when;
 222                 }
 223                 else
 224                 {
 225                         int cost;
 226                         if (r_ptr->flags2 & (RF2_BASH_DOOR | RF2_OPEN_DOOR))
 227                         {
 228                                 cost = g_ptr->dist;
 229                         }
 230                         else
 231                         {
 232                                 cost = g_ptr->cost;
 233                         }
 234
 235                         if ((cost == 0) || (best < cost)) continue;
 236
 237                         best = cost;
 238                 }
 239
 240                 *yp = target_ptr->y + 16 * ddy_ddd[i];
 241                 *xp = target_ptr->x + 16 * ddx_ddd[i];
 242         }
 243 }
 244
 245
 246 /*!
 247  * @brief モンスターがプレイヤーから逃走することが可能なマスを走査する /
 248  * Provide a location to flee to, but give the player a wide berth.
 249  * @param m_idx モンスターの参照ID
 250  * @param yp 移動先のマスのY座標を返す参照ポインタ
 251  * @param xp 移動先のマスのX座標を返す参照ポインタ
 252  * @return 有効なマスがあった場合TRUEを返す
 253  * @details
 254  * A monster may wish to flee to a location that is behind the player,\n
 255  * but instead of heading directly for it, the monster should "swerve"\n
 256  * around the player so that he has a smaller chance of getting hit.\n
 257  */
 258 static bool sweep_runnable_away_grid(floor_type *floor_ptr, MONSTER_IDX m_idx, POSITION *yp, POSITION *xp)
 259 {
 260         POSITION gy = 0, gx = 0;
 261
 262         monster_type *m_ptr = &floor_ptr->m_list[m_idx];
 263         POSITION fy = m_ptr->fy;
 264         POSITION fx = m_ptr->fx;
 265
 266         POSITION y1 = fy - (*yp);
 267         POSITION x1 = fx - (*xp);
 268
 269         int score = -1;
 270         for (int i = 7; i >= 0; i--)
 271         {
 272                 POSITION y = fy + ddy_ddd[i];
 273                 POSITION x = fx + ddx_ddd[i];
 274                 if (!in_bounds2(floor_ptr, y, x)) continue;
 275
 276                 POSITION dis = distance(y, x, y1, x1);
 277                 POSITION s = 5000 / (dis + 3) - 500 / (floor_ptr->grid_array[y][x].dist + 1);
 278                 if (s < 0) s = 0;
 279
 280                 if (s < score) continue;
 281
 282                 score = s;
 283                 gy = y;
 284                 gx = x;
 285         }
 286
 287         if (score == -1) return FALSE;
 288
 289         (*yp) = fy - gy;
 290         (*xp) = fx - gx;
 291
 292         return TRUE;
 293 }
 294
 295
 296 /*!
 297  * todo 分割したいが条件が多すぎて適切な関数名と詳細処理を追いきれない……
 298  * @brief モンスターの移動方向を返す /
 299  * Choose "logical" directions for monster movement
 300  * @param target_ptr プレーヤーへの参照ポインタ
 301  * @param m_idx モンスターの参照ID
 302  * @param mm 移動方向を返す方向IDの参照ポインタ
 303  * @return 有効方向があった場合TRUEを返す
 304  */
 305 bool get_movable_grid(player_type *target_ptr, MONSTER_IDX m_idx, DIRECTION *mm)
 306 {
 307         floor_type *floor_ptr = target_ptr->current_floor_ptr;
 308         monster_type *m_ptr = &floor_ptr->m_list[m_idx];
 309         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 310         POSITION y = 0, x = 0;
 311         POSITION y2 = target_ptr->y;
 312         POSITION x2 = target_ptr->x;
 313         bool done = FALSE;
 314         bool will_run = mon_will_run(target_ptr, m_idx);
 315         grid_type *g_ptr;
 316         bool no_flow = ((m_ptr->mflag2 & MFLAG2_NOFLOW) != 0) && (floor_ptr->grid_array[m_ptr->fy][m_ptr->fx].cost > 2);
 317         bool can_pass_wall = ((r_ptr->flags2 & RF2_PASS_WALL) != 0) && ((m_idx != target_ptr->riding) || target_ptr->pass_wall);
 318
 319         if (!will_run && m_ptr->target_y)
 320         {
 321                 int t_m_idx = floor_ptr->grid_array[m_ptr->target_y][m_ptr->target_x].m_idx;
 322                 if ((t_m_idx > 0) &&
 323                         are_enemies(target_ptr, m_ptr, &floor_ptr->m_list[t_m_idx]) &&
 324                         los(target_ptr, m_ptr->fy, m_ptr->fx, m_ptr->target_y, m_ptr->target_x) &&
 325                         projectable(target_ptr, m_ptr->fy, m_ptr->fx, m_ptr->target_y, m_ptr->target_x))
 326                 {
 327                         y = m_ptr->fy - m_ptr->target_y;
 328                         x = m_ptr->fx - m_ptr->target_x;
 329                         done = TRUE;
 330                 }
 331         }
 332
 333         if (!done && !will_run && is_hostile(m_ptr) &&
 334                 (r_ptr->flags1 & RF1_FRIENDS) &&
 335                 ((los(target_ptr, m_ptr->fy, m_ptr->fx, target_ptr->y, target_ptr->x) && projectable(target_ptr, m_ptr->fy, m_ptr->fx, target_ptr->y, target_ptr->x)) ||
 336                 (floor_ptr->grid_array[m_ptr->fy][m_ptr->fx].dist < MAX_SIGHT / 2)))
 337         {
 338                 if ((r_ptr->flags3 & RF3_ANIMAL) && !can_pass_wall &&
 339                         !(r_ptr->flags2 & RF2_KILL_WALL))
 340                 {
 341                         int room = 0;
 342                         for (int i = 0; i < 8; i++)
 343                         {
 344                                 int xx = target_ptr->x + ddx_ddd[i];
 345                                 int yy = target_ptr->y + ddy_ddd[i];
 346
 347                                 if (!in_bounds2(floor_ptr, yy, xx)) continue;
 348
 349                                 g_ptr = &floor_ptr->grid_array[yy][xx];
 350                                 if (monster_can_cross_terrain(target_ptr, g_ptr->feat, r_ptr, 0))
 351                                 {
 352                                         room++;
 353                                 }
 354                         }
 355
 356                         if (floor_ptr->grid_array[target_ptr->y][target_ptr->x].info & CAVE_ROOM) room -= 2;
 357                         if (!r_ptr->flags4 && !r_ptr->a_ability_flags1 && !r_ptr->a_ability_flags2) room -= 2;
 358
 359                         if (room < (8 * (target_ptr->chp + target_ptr->csp)) /
 360                                 (target_ptr->mhp + target_ptr->msp))
 361                         {
 362                                 if (find_hiding(target_ptr, m_idx, &y, &x)) done = TRUE;
 363                         }
 364                 }
 365
 366                 if (!done && (floor_ptr->grid_array[m_ptr->fy][m_ptr->fx].dist < 3))
 367                 {
 368                         for (int i = 0; i < 8; i++)
 369                         {
 370                                 y2 = target_ptr->y + ddy_ddd[(m_idx + i) & 7];
 371                                 x2 = target_ptr->x + ddx_ddd[(m_idx + i) & 7];
 372                                 if ((m_ptr->fy == y2) && (m_ptr->fx == x2))
 373                                 {
 374                                         y2 = target_ptr->y;
 375                                         x2 = target_ptr->x;
 376                                         break;
 377                                 }
 378
 379                                 if (!in_bounds2(floor_ptr, y2, x2)) continue;
 380                                 if (!monster_can_enter(target_ptr, y2, x2, r_ptr, 0)) continue;
 381
 382                                 break;
 383                         }
 384
 385                         y = m_ptr->fy - y2;
 386                         x = m_ptr->fx - x2;
 387                         done = TRUE;
 388                 }
 389         }
 390
 391         if (!done)
 392         {
 393                 sweep_movable_grid(target_ptr, m_idx, &y2, &x2, no_flow);
 394                 y = m_ptr->fy - y2;
 395                 x = m_ptr->fx - x2;
 396         }
 397
 398         if (is_pet(m_ptr) && will_run)
 399         {
 400                 y = (-y), x = (-x);
 401         }
 402         else
 403         {
 404                 if (!done && will_run)
 405                 {
 406                         int tmp_x = (-x);
 407                         int tmp_y = (-y);
 408                         if (find_safety(target_ptr, m_idx, &y, &x) && !no_flow)
 409                         {
 410                                 if (sweep_runnable_away_grid(target_ptr->current_floor_ptr, m_idx, &y, &x))
 411                                         done = TRUE;
 412                         }
 413
 414                         if (!done)
 415                         {
 416                                 y = tmp_y;
 417                                 x = tmp_x;
 418                         }
 419                 }
 420         }
 421
 422         if (!x && !y) return FALSE;
 423
 424         store_moves_val(mm, y, x);
 425         return TRUE;
 426 }