[Refactor] #3914 プレイヤー位置の周辺を取得するリテラルな処理を全てget_neighbor() でカプセル化した

diff --git a/src/action/run-execution.cpp b/src/action/run-execution.cpp
index dd9885d..3e119b6 100644 (file)
--- a/src/action/run-execution.cpp
+++ b/src/action/run-execution.cpp
@@ -112,24 +112,24 @@ static void run_init(PlayerType *player_ptr, DIRECTION dir)
     bool deepright = false;
     bool shortright = false;
     bool shortleft = false;
-    player_ptr->run_py = player_ptr->y;
-    player_ptr->run_px = player_ptr->x;
-    int row = player_ptr->y + ddy[dir];
-    int col = player_ptr->x + ddx[dir];
-    ignore_avoid_run = cave_has_flag_bold(player_ptr->current_floor_ptr, row, col, TerrainCharacteristics::AVOID_RUN);
+    const auto pos = player_ptr->get_position();
+    player_ptr->run_py = pos.y;
+    player_ptr->run_px = pos.x;
+    const auto pos_neighbor = player_ptr->get_neighbor(dir);
+    ignore_avoid_run = cave_has_flag_bold(player_ptr->current_floor_ptr, pos_neighbor.y, pos_neighbor.x, TerrainCharacteristics::AVOID_RUN);
     int i = chome[dir];
-    if (see_wall(player_ptr, cycle[i + 1], player_ptr->y, player_ptr->x)) {
+    if (see_wall(player_ptr, cycle[i + 1], pos.y, pos.x)) {
         find_breakleft = true;
         shortleft = true;
-    } else if (see_wall(player_ptr, cycle[i + 1], row, col)) {
+    } else if (see_wall(player_ptr, cycle[i + 1], pos_neighbor.y, pos_neighbor.x)) {
         find_breakleft = true;
         deepleft = true;
     }
 
-    if (see_wall(player_ptr, cycle[i - 1], player_ptr->y, player_ptr->x)) {
+    if (see_wall(player_ptr, cycle[i - 1], pos.y, pos.x)) {
         find_breakright = true;
         shortright = true;
-    } else if (see_wall(player_ptr, cycle[i - 1], row, col)) {
+    } else if (see_wall(player_ptr, cycle[i - 1], pos_neighbor.y, pos_neighbor.x)) {
         find_breakright = true;
         deepright = true;
     }
@@ -149,7 +149,7 @@ static void run_init(PlayerType *player_ptr, DIRECTION dir)
         return;
     }
 
-    if (!see_wall(player_ptr, cycle[i], row, col)) {
+    if (!see_wall(player_ptr, cycle[i], pos_neighbor.y, pos_neighbor.x)) {
         return;
     }
 
@@ -224,7 +224,7 @@ static bool run_test(PlayerType *player_ptr)
     auto option2 = 0;
     for (auto i = -max; i <= max; i++) {
         int new_dir = cycle[chome[prev_dir] + i];
-        const Pos2D pos(player_ptr->y + ddy[new_dir], player_ptr->x + ddx[new_dir]);
+        const auto pos = player_ptr->get_neighbor(new_dir);
         const auto &grid = floor.get_grid(pos);
         if (grid.has_monster()) {
             const auto &monster = floor.m_list[grid.m_idx];
@@ -345,10 +345,9 @@ static bool run_test(PlayerType *player_ptr)
         return see_wall(player_ptr, find_current, player_ptr->y, player_ptr->x);
     }
 
-    int row = player_ptr->y + ddy[option];
-    int col = player_ptr->x + ddx[option];
-    if (!see_wall(player_ptr, option, row, col) || !see_wall(player_ptr, check_dir, row, col)) {
-        if (see_nothing(player_ptr, option, row, col) && see_nothing(player_ptr, option2, row, col)) {
+    const auto pos = player_ptr->get_neighbor(option);
+    if (!see_wall(player_ptr, option, pos.y, pos.x) || !see_wall(player_ptr, check_dir, pos.y, pos.x)) {
+        if (see_nothing(player_ptr, option, pos.y, pos.x) && see_nothing(player_ptr, option2, pos.y, pos.x)) {
             find_current = option;
             find_prevdir = option2;
             return see_wall(player_ptr, find_current, player_ptr->y, player_ptr->x);

diff --git a/src/action/travel-execution.cpp b/src/action/travel-execution.cpp
index cf4fe71..6c99c0a 100644 (file)
--- a/src/action/travel-execution.cpp
+++ b/src/action/travel-execution.cpp
@@ -55,15 +55,13 @@ static DIRECTION travel_test(PlayerType *player_ptr, DIRECTION prev_dir)
     }
 
     int max = (prev_dir & 0x01) + 1;
-    const Grid *g_ptr;
     for (int i = -max; i <= max; i++) {
         DIRECTION dir = cycle[chome[prev_dir] + i];
-        POSITION row = player_ptr->y + ddy[dir];
-        POSITION col = player_ptr->x + ddx[dir];
-        g_ptr = &floor_ptr->grid_array[row][col];
-        if (g_ptr->has_monster()) {
-            auto *m_ptr = &floor_ptr->m_list[g_ptr->m_idx];
-            if (m_ptr->ml) {
+        const auto pos = player_ptr->get_neighbor(dir);
+        const auto &grid = floor_ptr->get_grid(pos);
+        if (grid.has_monster()) {
+            const auto &monster = floor_ptr->m_list[grid.m_idx];
+            if (monster.ml) {
                 return 0;
             }
         }
@@ -83,12 +81,13 @@ static DIRECTION travel_test(PlayerType *player_ptr, DIRECTION prev_dir)
         return 0;
     }
 
-    g_ptr = &floor_ptr->grid_array[player_ptr->y + ddy[new_dir]][player_ptr->x + ddx[new_dir]];
-    if (!easy_open && is_closed_door(player_ptr, g_ptr->feat)) {
+    const auto pos_new = player_ptr->get_neighbor(new_dir);
+    const auto &grid = floor_ptr->get_grid(pos_new);
+    if (!easy_open && is_closed_door(player_ptr, grid.feat)) {
         return 0;
     }
 
-    if (!g_ptr->mimic && !trap_can_be_ignored(player_ptr, g_ptr->feat)) {
+    if (!grid.mimic && !trap_can_be_ignored(player_ptr, grid.feat)) {
         return 0;
     }
 

diff --git a/src/cmd-action/cmd-open-close.cpp b/src/cmd-action/cmd-open-close.cpp
index 902dbb1..8d041a9 100644 (file)
--- a/src/cmd-action/cmd-open-close.cpp
+++ b/src/cmd-action/cmd-open-close.cpp
@@ -125,7 +125,7 @@ void do_cmd_open(PlayerType *player_ptr)
 
     int dir;
     if (get_rep_dir(player_ptr, &dir, true)) {
-        const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+        const auto pos = player_ptr->get_neighbor(dir);
         const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
         const auto o_idx = chest_check(player_ptr->current_floor_ptr, pos, false);
         if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::OPEN) && !o_idx) {
@@ -175,7 +175,7 @@ void do_cmd_close(PlayerType *player_ptr)
     auto more = false;
     int dir;
     if (get_rep_dir(player_ptr, &dir)) {
-        const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+        const auto pos = player_ptr->get_neighbor(dir);
         const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
         if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::CLOSE)) {
             msg_print(_("そこには閉じるものが見当たらない。", "You see nothing there to close."));
@@ -225,7 +225,7 @@ void do_cmd_disarm(PlayerType *player_ptr)
     int dir;
     auto more = false;
     if (get_rep_dir(player_ptr, &dir, true)) {
-        const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+        const auto pos = player_ptr->get_neighbor(dir);
         const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
         const auto feat = grid.get_feat_mimic();
         const auto o_idx = chest_check(player_ptr->current_floor_ptr, pos, true);
@@ -280,7 +280,7 @@ void do_cmd_bash(PlayerType *player_ptr)
 
     int dir;
     if (get_rep_dir(player_ptr, &dir)) {
-        const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+        const auto pos = player_ptr->get_neighbor(dir);
         const Grid &grid = player_ptr->current_floor_ptr->get_grid(pos);
         if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::BASH)) {
             msg_print(_("そこには体当たりするものが見当たらない。", "You see nothing there to bash."));
@@ -347,7 +347,7 @@ void do_cmd_spike(PlayerType *player_ptr)
         return;
     }
 
-    const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+    const auto pos = player_ptr->get_neighbor(dir);
     const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
     const auto &terrain_mimic = grid.get_terrain_mimic();
     INVENTORY_IDX i_idx;

diff --git a/src/cmd-action/cmd-others.cpp b/src/cmd-action/cmd-others.cpp
index 3b4fb50..c99619c 100644 (file)
--- a/src/cmd-action/cmd-others.cpp
+++ b/src/cmd-action/cmd-others.cpp
@@ -67,7 +67,7 @@ static bool exe_alter(PlayerType *player_ptr)
         return false;
     }
 
-    const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+    const auto pos = player_ptr->get_neighbor(dir);
     const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
     const auto &terrain = grid.get_terrain_mimic();
     PlayerEnergy(player_ptr).set_player_turn_energy(100);

diff --git a/src/cmd-action/cmd-tunnel.cpp b/src/cmd-action/cmd-tunnel.cpp
index c260b7c..ea26d5f 100644 (file)
--- a/src/cmd-action/cmd-tunnel.cpp
+++ b/src/cmd-action/cmd-tunnel.cpp
@@ -49,7 +49,7 @@ void do_cmd_tunnel(PlayerType *player_ptr)
     }
 
     auto more = false;
-    const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+    const auto pos = player_ptr->get_neighbor(dir);
     const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
     const auto &terrain_mimic = grid.get_terrain_mimic();
     if (terrain_mimic.flags.has(TerrainCharacteristics::DOOR)) {

diff --git a/src/core/player-processor.cpp b/src/core/player-processor.cpp
index 7782aa7..f107c60 100644 (file)
--- a/src/core/player-processor.cpp
+++ b/src/core/player-processor.cpp
@@ -82,11 +82,9 @@ static void process_fishing(PlayerType *player_ptr)
         const auto r_idx = get_mon_num(player_ptr, 0, level, PM_NONE);
         msg_print(nullptr);
         if (MonsterRace(r_idx).is_valid() && one_in_(2)) {
-            POSITION y, x;
-            y = player_ptr->y + ddy[player_ptr->fishing_dir];
-            x = player_ptr->x + ddx[player_ptr->fishing_dir];
-            if (place_specific_monster(player_ptr, 0, y, x, r_idx, PM_NO_KAGE)) {
-                const auto m_name = monster_desc(player_ptr, &floor_ptr->m_list[floor_ptr->grid_array[y][x].m_idx], 0);
+            const auto pos = player_ptr->get_neighbor(player_ptr->fishing_dir);
+            if (place_specific_monster(player_ptr, 0, pos.y, pos.x, r_idx, PM_NO_KAGE)) {
+                const auto m_name = monster_desc(player_ptr, &floor_ptr->m_list[floor_ptr->get_grid(pos).m_idx], 0);
                 msg_print(_(format("%sが釣れた！", m_name.data()), "You have a good catch!"));
                 success = true;
             }

diff --git a/src/mind/mind-archer.cpp b/src/mind/mind-archer.cpp
index 133d913..3bc87d5 100644 (file)
--- a/src/mind/mind-archer.cpp
+++ b/src/mind/mind-archer.cpp
@@ -111,7 +111,7 @@ bool create_ammo(PlayerType *player_ptr)
             return false;
         }
 
-        const Pos2D pos(player_ptr->y + ddy[dir], player_ptr->x + ddx[dir]);
+        const auto pos = player_ptr->get_neighbor(dir);
         const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
         if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::CAN_DIG)) {
             msg_print(_("そこには岩石がない。", "You need a pile of rubble."));

diff --git a/src/mind/mind-force-trainer.cpp b/src/mind/mind-force-trainer.cpp
index 85ccbf4..43769d0 100644 (file)
--- a/src/mind/mind-force-trainer.cpp
+++ b/src/mind/mind-force-trainer.cpp
@@ -206,55 +206,52 @@ bool shock_power(PlayerType *player_ptr)
         return false;
     }
 
-    POSITION y = player_ptr->y + ddy[dir];
-    POSITION x = player_ptr->x + ddx[dir];
+    auto pos = player_ptr->get_neighbor(dir);
     PLAYER_LEVEL plev = player_ptr->lev;
     int dam = damroll(8 + ((plev - 5) / 4) + boost / 12, 8);
     fire_beam(player_ptr, AttributeType::MISSILE, dir, dam);
-    if (!player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+    auto &floor = *player_ptr->current_floor_ptr;
+    const auto &grid = floor.get_grid(pos);
+    if (!grid.has_monster()) {
         return true;
     }
 
-    POSITION ty = y, tx = x;
-    POSITION oy = y, ox = x;
-    MONSTER_IDX m_idx = player_ptr->current_floor_ptr->grid_array[y][x].m_idx;
-    auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
-    auto *r_ptr = &m_ptr->get_monrace();
-    const auto m_name = monster_desc(player_ptr, m_ptr, 0);
+    auto pos_target = pos;
+    const auto pos_origin = pos;
+    const auto m_idx = grid.m_idx;
+    auto &monster = floor.m_list[m_idx];
+    const auto &monrace = monster.get_monrace();
+    const auto m_name = monster_desc(player_ptr, &monster, 0);
 
-    if (randint1(r_ptr->level * 3 / 2) > randint0(dam / 2) + dam / 2) {
+    if (randint1(monrace.level * 3 / 2) > randint0(dam / 2) + dam / 2) {
         msg_format(_("%sは飛ばされなかった。", "%s^ was not blown away."), m_name.data());
         return true;
     }
 
     for (int i = 0; i < 5; i++) {
-        y += ddy[dir];
-        x += ddx[dir];
-        if (is_cave_empty_bold(player_ptr, y, x)) {
-            ty = y;
-            tx = x;
+        pos = Pos2D(pos.y + ddy[dir], pos.x + ddx[dir]);
+        if (is_cave_empty_bold(player_ptr, pos.y, pos.x)) {
+            pos_target = pos;
         } else {
             break;
         }
     }
 
-    bool is_shock_successful = ty != oy;
-    is_shock_successful |= tx != ox;
-    if (is_shock_successful) {
+    if (pos_target != pos_origin) {
         return true;
     }
 
     msg_format(_("%sを吹き飛ばした！", "You blow %s away!"), m_name.data());
-    player_ptr->current_floor_ptr->grid_array[oy][ox].m_idx = 0;
-    player_ptr->current_floor_ptr->grid_array[ty][tx].m_idx = m_idx;
-    m_ptr->fy = ty;
-    m_ptr->fx = tx;
+    floor.get_grid(pos_origin).m_idx = 0;
+    floor.get_grid(pos_target).m_idx = m_idx;
+    monster.fy = pos_target.y;
+    monster.fx = pos_target.x;
 
     update_monster(player_ptr, m_idx, true);
-    lite_spot(player_ptr, oy, ox);
-    lite_spot(player_ptr, ty, tx);
+    lite_spot(player_ptr, pos_origin.y, pos_origin.x);
+    lite_spot(player_ptr, pos_target.y, pos_target.x);
 
-    if (r_ptr->brightness_flags.has_any_of(ld_mask)) {
+    if (monrace.brightness_flags.has_any_of(ld_mask)) {
         RedrawingFlagsUpdater::get_instance().set_flag(StatusRecalculatingFlag::MONSTER_LITE);
     }
 

diff --git a/src/mind/monk-attack.cpp b/src/mind/monk-attack.cpp
index def04ea..70b42b5 100644 (file)
--- a/src/mind/monk-attack.cpp
+++ b/src/mind/monk-attack.cpp
@@ -270,9 +270,11 @@ bool double_attack(PlayerType *player_ptr)
     if (!get_rep_dir(player_ptr, &dir)) {
         return false;
     }
-    POSITION y = player_ptr->y + ddy[dir];
-    POSITION x = player_ptr->x + ddx[dir];
-    if (!player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+
+    const auto pos = player_ptr->get_neighbor(dir);
+    const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
+    const auto has_monster = grid.has_monster();
+    if (!has_monster) {
         msg_print(_("その方向にはモンスターはいません。", "You don't see any monster in this direction"));
         msg_print(nullptr);
         return true;
@@ -286,10 +288,10 @@ bool double_attack(PlayerType *player_ptr)
         msg_print(_("オラオラオラオラオラオラオラオラオラオラオラオラ！！！", "Oraoraoraoraoraoraoraoraoraoraoraoraoraoraoraoraora!!!!"));
     }
 
-    do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
-    if (player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+    do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
+    if (has_monster) {
         handle_stuff(player_ptr);
-        do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
+        do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
     }
 
     player_ptr->energy_need += ENERGY_NEED();

diff --git a/src/realm/realm-hissatsu.cpp b/src/realm/realm-hissatsu.cpp
index 1c04346..901d91e 100644 (file)
--- a/src/realm/realm-hissatsu.cpp
+++ b/src/realm/realm-hissatsu.cpp
@@ -375,9 +375,9 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
             if (grid.has_monster()) {
                 Pos2D target(pos.y, pos.x);
                 Pos2D origin(pos.y, pos.x);
-                auto m_idx = grid.m_idx;
-                auto *m_ptr = &floor.m_list[m_idx];
-                const auto m_name = monster_desc(player_ptr, m_ptr, 0);
+                const auto m_idx = grid.m_idx;
+                auto &monster = floor.m_list[m_idx];
+                const auto m_name = monster_desc(player_ptr, &monster, 0);
                 Pos2D neighbor(pos.y, pos.x);
                 for (auto i = 0; i < 5; i++) {
                     neighbor.y += ddy[dir];
@@ -392,14 +392,14 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
                     msg_format(_("%sを吹き飛ばした！", "You blow %s away!"), m_name.data());
                     floor.get_grid(origin).m_idx = 0;
                     floor.get_grid(target).m_idx = m_idx;
-                    m_ptr->fy = target.y;
-                    m_ptr->fx = target.x;
+                    monster.fy = target.y;
+                    monster.fx = target.x;
 
                     update_monster(player_ptr, m_idx, true);
                     lite_spot(player_ptr, origin.y, origin.x);
                     lite_spot(player_ptr, target.y, target.x);
 
-                    if (m_ptr->get_monrace().brightness_flags.has_any_of(ld_mask)) {
+                    if (monster.get_monrace().brightness_flags.has_any_of(ld_mask)) {
                         RedrawingFlagsUpdater::get_instance().set_flag(StatusRecalculatingFlag::MONSTER_LITE);
                     }
                 }
@@ -952,20 +952,17 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            POSITION x, y;
-
             if (!get_rep_dir(player_ptr, &dir)) {
                 return std::nullopt;
             }
 
-            y = player_ptr->y + ddy[dir];
-            x = player_ptr->x + ddx[dir];
-
-            if (player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
-                do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
-                if (player_ptr->current_floor_ptr->grid_array[y][x].has_monster()) {
+            const auto pos = player_ptr->get_neighbor(dir);
+            const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
+            if (grid.has_monster()) {
+                do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
+                if (grid.has_monster()) {
                     handle_stuff(player_ptr);
-                    do_cmd_attack(player_ptr, y, x, HISSATSU_NONE);
+                    do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
                 }
             } else {
                 msg_print(_("その方向にはモンスターはいません。", "You don't see any monster in this direction"));

diff --git a/src/specific-object/monster-ball.cpp b/src/specific-object/monster-ball.cpp
index 214d0f0..47d1c81 100644 (file)
--- a/src/specific-object/monster-ball.cpp
+++ b/src/specific-object/monster-ball.cpp
@@ -95,12 +95,13 @@ static void restore_monster_nickname(MonsterEntity &monster, ItemEntity &item)
 
 static bool release_monster(PlayerType *player_ptr, ItemEntity &item, DIRECTION dir)
 {
-    auto r_idx = i2enum<MonsterRaceId>(item.pval);
-    if (!monster_can_enter(player_ptr, player_ptr->y + ddy[dir], player_ptr->x + ddx[dir], &monraces_info[r_idx], 0)) {
+    const auto r_idx = i2enum<MonsterRaceId>(item.pval);
+    const auto pos = player_ptr->get_neighbor(dir);
+    if (!monster_can_enter(player_ptr, pos.y, pos.x, &monraces_info[r_idx], 0)) {
         return false;
     }
 
-    if (!place_specific_monster(player_ptr, 0, player_ptr->y + ddy[dir], player_ptr->x + ddx[dir], r_idx, PM_FORCE_PET | PM_NO_KAGE)) {
+    if (!place_specific_monster(player_ptr, 0, pos.y, pos.x, r_idx, PM_FORCE_PET | PM_NO_KAGE)) {
         return false;
     }
 

diff --git a/src/spell-class/spells-mirror-master.cpp b/src/spell-class/spells-mirror-master.cpp
index dd13908..1c74061 100644 (file)
--- a/src/spell-class/spells-mirror-master.cpp
+++ b/src/spell-class/spells-mirror-master.cpp
@@ -205,26 +205,14 @@ void SpellsMirrorMaster::seal_of_mirror(const int dam)
 
 void SpellsMirrorMaster::seeker_ray(int dir, int dam)
 {
-    POSITION tx = this->player_ptr->x + ddx[dir];
-    POSITION ty = this->player_ptr->y + ddy[dir];
-    if ((dir == 5) && target_okay(this->player_ptr)) {
-        tx = target_col;
-        ty = target_row;
-    }
-
-    project_seeker_ray(tx, ty, dam);
+    const auto pos = ((dir == 5) && target_okay(this->player_ptr)) ? Pos2D(target_row, target_col) : this->player_ptr->get_neighbor(dir);
+    project_seeker_ray(pos.x, pos.y, dam);
 }
 
 void SpellsMirrorMaster::super_ray(int dir, int dam)
 {
-    POSITION tx = this->player_ptr->x + ddx[dir];
-    POSITION ty = this->player_ptr->y + ddy[dir];
-    if ((dir == 5) && target_okay(this->player_ptr)) {
-        tx = target_col;
-        ty = target_row;
-    }
-
-    project_super_ray(tx, ty, dam);
+    const auto pos = ((dir == 5) && target_okay(this->player_ptr)) ? Pos2D(target_row, target_col) : this->player_ptr->get_neighbor(dir);
+    project_super_ray(pos.x, pos.y, dam);
 }
 
 /*!

diff --git a/src/spell-kind/spells-launcher.cpp b/src/spell-kind/spells-launcher.cpp
index fe4d1fa..f7d3b58 100644 (file)
--- a/src/spell-kind/spells-launcher.cpp
+++ b/src/spell-kind/spells-launcher.cpp
@@ -279,12 +279,6 @@ bool fire_bolt_or_beam(PlayerType *player_ptr, PERCENTAGE prob, AttributeType ty
 bool project_hook(PlayerType *player_ptr, AttributeType typ, DIRECTION dir, int dam, BIT_FLAGS flg)
 {
     flg |= (PROJECT_THRU);
-    POSITION tx = player_ptr->x + ddx[dir];
-    POSITION ty = player_ptr->y + ddy[dir];
-    if ((dir == 5) && target_okay(player_ptr)) {
-        tx = target_col;
-        ty = target_row;
-    }
-
-    return project(player_ptr, 0, 0, ty, tx, dam, typ, flg).notice;
+    const auto pos = ((dir == 5) && target_okay(player_ptr)) ? Pos2D(target_row, target_col) : player_ptr->get_neighbor(dir);
+    return project(player_ptr, 0, 0, pos.y, pos.x, dam, typ, flg).notice;
 }

diff --git a/src/spell-kind/spells-teleport.cpp b/src/spell-kind/spells-teleport.cpp
index 64ae90f..7291136 100644 (file)
--- a/src/spell-kind/spells-teleport.cpp
+++ b/src/spell-kind/spells-teleport.cpp
@@ -55,49 +55,38 @@
  */
 bool teleport_swap(PlayerType *player_ptr, DIRECTION dir)
 {
-    POSITION tx, ty;
-    if ((dir == 5) && target_okay(player_ptr)) {
-        tx = target_col;
-        ty = target_row;
-    } else {
-        tx = player_ptr->x + ddx[dir];
-        ty = player_ptr->y + ddy[dir];
-    }
-
+    const auto pos = ((dir == 5) && target_okay(player_ptr)) ? Pos2D(target_row, target_col) : player_ptr->get_neighbor(dir);
     if (player_ptr->anti_tele) {
         msg_print(_("不思議な力がテレポートを防いだ！", "A mysterious force prevents you from teleporting!"));
         return false;
     }
 
-    Grid *g_ptr;
-    g_ptr = &player_ptr->current_floor_ptr->grid_array[ty][tx];
-    if (!g_ptr->has_monster() || (g_ptr->m_idx == player_ptr->riding)) {
+    const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
+    if (!grid.has_monster() || (grid.m_idx == player_ptr->riding)) {
         msg_print(_("それとは場所を交換できません。", "You can't trade places with that!"));
         return false;
     }
 
-    if ((g_ptr->is_icky()) || (distance(ty, tx, player_ptr->y, player_ptr->x) > player_ptr->lev * 3 / 2 + 10)) {
+    if ((grid.is_icky()) || (distance(pos.y, pos.x, player_ptr->y, player_ptr->x) > player_ptr->lev * 3 / 2 + 10)) {
         msg_print(_("失敗した。", "Failed to swap."));
         return false;
     }
 
-    MonsterEntity *m_ptr;
-    MonsterRaceInfo *r_ptr;
-    m_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
-    r_ptr = &m_ptr->get_monrace();
+    const auto &monster = player_ptr->current_floor_ptr->m_list[grid.m_idx];
+    auto &monrace = monster.get_monrace();
 
-    (void)set_monster_csleep(player_ptr, g_ptr->m_idx, 0);
+    (void)set_monster_csleep(player_ptr, grid.m_idx, 0);
 
-    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
+    if (monrace.resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
         msg_print(_("テレポートを邪魔された！", "Your teleportation is blocked!"));
-        if (is_original_ap_and_seen(player_ptr, m_ptr)) {
-            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
+        if (is_original_ap_and_seen(player_ptr, &monster)) {
+            monrace.r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
         }
         return false;
     }
 
     sound(SOUND_TELEPORT);
-    (void)move_player_effect(player_ptr, ty, tx, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
+    (void)move_player_effect(player_ptr, pos.y, pos.x, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
     return true;
 }