[Refactor] #3901 get_direction() の引数からポインタを除き、戻り値をoptional に変えた

diff --git a/src/action/mutation-execution.cpp b/src/action/mutation-execution.cpp
index aa5daa8..2f495ae 100644 (file)
--- a/src/action/mutation-execution.cpp
+++ b/src/action/mutation-execution.cpp
@@ -63,11 +63,11 @@
  */
 bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
 {
-    DIRECTION dir = 0;
     PLAYER_LEVEL lvl = player_ptr->lev;
     auto &floor = *player_ptr->current_floor_ptr;
     switch (power) {
-    case PlayerMutationType::SPIT_ACID:
+    case PlayerMutationType::SPIT_ACID: {
+        auto dir = 0;
         if (!get_aim_dir(player_ptr, &dir)) {
             return false;
         }
@@ -76,7 +76,9 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         msg_print(_("酸を吐きかけた...", "You spit acid..."));
         fire_ball(player_ptr, AttributeType::ACID, dir, lvl, 1 + (lvl / 30));
         return true;
-    case PlayerMutationType::BR_FIRE:
+    }
+    case PlayerMutationType::BR_FIRE: {
+        auto dir = 0;
         if (!get_aim_dir(player_ptr, &dir)) {
             return false;
         }
@@ -85,7 +87,9 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         msg_print(_("あなたは火炎のブレスを吐いた...", "You breathe fire..."));
         fire_breath(player_ptr, AttributeType::FIRE, dir, lvl * 2, 1 + (lvl / 20));
         return true;
-    case PlayerMutationType::HYPN_GAZE:
+    }
+    case PlayerMutationType::HYPN_GAZE: {
+        auto dir = 0;
         if (!get_aim_dir(player_ptr, &dir)) {
             return false;
         }
@@ -93,7 +97,9 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         msg_print(_("あなたの目は幻惑的になった...", "Your eyes look mesmerizing..."));
         (void)charm_monster(player_ptr, dir, lvl);
         return true;
-    case PlayerMutationType::TELEKINES:
+    }
+    case PlayerMutationType::TELEKINES: {
+        auto dir = 0;
         if (!get_aim_dir(player_ptr, &dir)) {
             return false;
         }
@@ -101,11 +107,13 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         msg_print(_("集中している...", "You concentrate..."));
         fetch_item(player_ptr, dir, lvl * 10, true);
         return true;
+    }
     case PlayerMutationType::VTELEPORT:
         msg_print(_("集中している...", "You concentrate..."));
         teleport_player(player_ptr, 10 + 4 * lvl, TELEPORT_SPONTANEOUS);
         return true;
-    case PlayerMutationType::MIND_BLST:
+    case PlayerMutationType::MIND_BLST: {
+        auto dir = 0;
         if (!get_aim_dir(player_ptr, &dir)) {
             return false;
         }
@@ -113,6 +121,7 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         msg_print(_("集中している...", "You concentrate..."));
         fire_bolt(player_ptr, AttributeType::PSI, dir, damroll(3 + ((lvl - 1) / 5), 3));
         return true;
+    }
     case PlayerMutationType::RADIATION:
         msg_print(_("体から放射能が発生した！", "Radiation flows from your body!"));
         fire_ball(player_ptr, AttributeType::NUKE, 0, (lvl * 2), 3 + (lvl / 20));
@@ -133,7 +142,8 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         return true;
     case PlayerMutationType::EAT_ROCK:
         return eat_rock(player_ptr);
-    case PlayerMutationType::SWAP_POS:
+    case PlayerMutationType::SWAP_POS: {
+        auto dir = 0;
         project_length = -1;
         if (!get_aim_dir(player_ptr, &dir)) {
             project_length = 0;
@@ -143,6 +153,7 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         (void)teleport_swap(player_ptr, dir);
         project_length = 0;
         return true;
+    }
     case PlayerMutationType::SHRIEK:
         stop_mouth(player_ptr);
         (void)fire_ball(player_ptr, AttributeType::SOUND, 0, 2 * lvl, 8);
@@ -230,21 +241,24 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         confuse_monsters(player_ptr, lvl * 4);
         turn_monsters(player_ptr, lvl * 4);
         return true;
-    case PlayerMutationType::LASER_EYE:
+    case PlayerMutationType::LASER_EYE: {
+        auto dir = 0;
         if (!get_aim_dir(player_ptr, &dir)) {
             return false;
         }
 
         fire_beam(player_ptr, AttributeType::LITE, dir, 2 * lvl);
         return true;
+    }
     case PlayerMutationType::RECALL:
         return recall_player(player_ptr, randint0(21) + 15);
     case PlayerMutationType::BANISH: {
-        if (!get_direction(player_ptr, &dir)) {
+        const auto dir = get_direction(player_ptr);
+        if (!dir) {
             return false;
         }
 
-        const auto pos = player_ptr->get_neighbor(dir);
+        const auto pos = player_ptr->get_neighbor(*dir);
         const auto &grid = floor.get_grid(pos);
         if (!grid.has_monster()) {
             msg_print(_("邪悪な存在を感じとれません！", "You sense no evil there!"));
@@ -279,18 +293,19 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         return true;
     }
     case PlayerMutationType::COLD_TOUCH: {
-        if (!get_direction(player_ptr, &dir)) {
+        const auto dir = get_direction(player_ptr);
+        if (!dir) {
             return false;
         }
 
-        const auto pos = player_ptr->get_neighbor(dir);
+        const auto pos = player_ptr->get_neighbor(*dir);
         const auto &grid = floor.get_grid(pos);
         if (!grid.has_monster()) {
             msg_print(_("あなたは何もない場所で手を振った。", "You wave your hands in the air."));
             return true;
         }
 
-        fire_bolt(player_ptr, AttributeType::COLD, dir, 2 * lvl);
+        fire_bolt(player_ptr, AttributeType::COLD, *dir, 2 * lvl);
         return true;
     }
     case PlayerMutationType::LAUNCHER:

diff --git a/src/cmd-action/cmd-pet.cpp b/src/cmd-action/cmd-pet.cpp
index dce3d8f..dbad4ec 100644 (file)
--- a/src/cmd-action/cmd-pet.cpp
+++ b/src/cmd-action/cmd-pet.cpp
@@ -197,12 +197,12 @@ void do_cmd_pet_dismiss(PlayerType *player_ptr)
  */
 bool do_cmd_riding(PlayerType *player_ptr, bool force)
 {
-    int dir;
-    if (!get_direction(player_ptr, &dir)) {
+    const auto dir = get_direction(player_ptr);
+    if (!dir) {
         return false;
     }
 
-    const auto pos = player_ptr->get_neighbor(dir);
+    const auto pos = player_ptr->get_neighbor(*dir);
     auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
 
     PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });

diff --git a/src/mind/mind-berserker.cpp b/src/mind/mind-berserker.cpp
index daeaf3f..4d04797 100644 (file)
--- a/src/mind/mind-berserker.cpp
+++ b/src/mind/mind-berserker.cpp
@@ -34,12 +34,12 @@ bool cast_berserk_spell(PlayerType *player_ptr, MindBerserkerType spell)
             return false;
         }
 
-        DIRECTION dir;
-        if (!get_direction(player_ptr, &dir) || (dir == 5)) {
+        const auto dir = get_direction(player_ptr);
+        if (!dir || (dir == 5)) {
             return false;
         }
 
-        const auto pos = player_ptr->get_neighbor(dir);
+        const auto pos = player_ptr->get_neighbor(*dir);
         const auto &floor = *player_ptr->current_floor_ptr;
         const auto &grid = floor.get_grid(pos);
         if (!grid.has_monster()) {
@@ -52,7 +52,7 @@ bool cast_berserk_spell(PlayerType *player_ptr, MindBerserkerType spell)
             return true;
         }
 
-        const Pos2D pos_new(pos.y + ddy[dir], pos.x + ddx[dir]);
+        const Pos2D pos_new(pos.y + ddy[*dir], pos.x + ddx[*dir]);
         const auto &grid_new = floor.get_grid(pos_new);
         if (player_can_enter(player_ptr, grid_new.feat, 0) && !is_trap(player_ptr, grid_new.feat) && !grid_new.has_monster()) {
             msg_print(nullptr);
@@ -62,12 +62,12 @@ bool cast_berserk_spell(PlayerType *player_ptr, MindBerserkerType spell)
         return true;
     }
     case MindBerserkerType::SMASH_TRAP: {
-        DIRECTION dir;
-        if (!get_direction(player_ptr, &dir)) {
+        const auto dir = get_direction(player_ptr);
+        if (!dir) {
             return false;
         }
 
-        exe_movement(player_ptr, dir, easy_disarm, true);
+        exe_movement(player_ptr, *dir, easy_disarm, true);
         return true;
     }
     case MindBerserkerType::QUAKE:

diff --git a/src/mind/mind-warrior.cpp b/src/mind/mind-warrior.cpp
index bc63355..a65a184 100644 (file)
--- a/src/mind/mind-warrior.cpp
+++ b/src/mind/mind-warrior.cpp
@@ -15,12 +15,12 @@
  */
 bool hit_and_away(PlayerType *player_ptr)
 {
-    DIRECTION dir;
-    if (!get_direction(player_ptr, &dir)) {
+    const auto dir = get_direction(player_ptr);
+    if (!dir) {
         return false;
     }
 
-    const auto pos = player_ptr->get_neighbor(dir);
+    const auto pos = player_ptr->get_neighbor(*dir);
     if (player_ptr->current_floor_ptr->get_grid(pos).has_monster()) {
         do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
         if (randint0(player_ptr->skill_dis) < 7) {

diff --git a/src/mutation/mutation-techniques.cpp b/src/mutation/mutation-techniques.cpp
index 2802379..00de91e 100644 (file)
--- a/src/mutation/mutation-techniques.cpp
+++ b/src/mutation/mutation-techniques.cpp
@@ -28,12 +28,12 @@
  */
 bool eat_rock(PlayerType *player_ptr)
 {
-    DIRECTION dir;
-    if (!get_direction(player_ptr, &dir)) {
+    const auto dir = get_direction(player_ptr);
+    if (!dir) {
         return false;
     }
 
-    const auto pos = player_ptr->get_neighbor(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();
     const auto &terrain_mimic = grid.get_terrain_mimic();

diff --git a/src/racial/racial-vampire.cpp b/src/racial/racial-vampire.cpp
index dd6305c..625a2eb 100644 (file)
--- a/src/racial/racial-vampire.cpp
+++ b/src/racial/racial-vampire.cpp
@@ -20,12 +20,12 @@ bool vampirism(PlayerType *player_ptr)
         return false;
     }
 
-    DIRECTION dir;
-    if (!get_direction(player_ptr, &dir)) {
+    const auto dir = get_direction(player_ptr);
+    if (!dir) {
         return false;
     }
 
-    const auto pos = player_ptr->get_neighbor(dir);
+    const auto pos = player_ptr->get_neighbor(*dir);
     const auto &grid = floor.get_grid(pos);
     stop_mouth(player_ptr);
     if (!grid.has_monster()) {
@@ -36,7 +36,7 @@ bool vampirism(PlayerType *player_ptr)
     msg_print(_("あなたはニヤリとして牙をむいた...", "You grin and bare your fangs..."));
 
     int dummy = player_ptr->lev * 2;
-    if (!hypodynamic_bolt(player_ptr, dir, dummy)) {
+    if (!hypodynamic_bolt(player_ptr, *dir, dummy)) {
         msg_print(_("げぇ！ひどい味だ。", "Yechh. That tastes foul."));
         return true;
     }

diff --git a/src/realm/realm-hissatsu.cpp b/src/realm/realm-hissatsu.cpp
index 887c16b..67a1280 100644 (file)
--- a/src/realm/realm-hissatsu.cpp
+++ b/src/realm/realm-hissatsu.cpp
@@ -69,7 +69,6 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
     bool desc = mode == SpellProcessType::DESCRIPTION;
     bool cast = mode == SpellProcessType::CAST;
 
-    DIRECTION dir;
     PLAYER_LEVEL plev = player_ptr->lev;
 
     switch (spell) {
@@ -83,6 +82,7 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
 
         if (cast) {
             project_length = 2;
+            int dir;
             if (!get_aim_dir(player_ptr, &dir)) {
                 return std::nullopt;
             }
@@ -100,10 +100,8 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
@@ -167,14 +165,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             if (player_ptr->current_floor_ptr->get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_FIRE);
             } else {
@@ -206,14 +202,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             if (player_ptr->current_floor_ptr->get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_MINEUCHI);
             } else {
@@ -257,15 +251,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
                 return std::nullopt;
             }
 
-            if (!get_direction(player_ptr, &dir)) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            if (dir == 5) {
-                return std::nullopt;
-            }
-
-            const auto pos_target = player_ptr->get_neighbor(dir);
+            const auto pos_target = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             const auto &grid_target = floor.get_grid(pos_target);
             if (!grid_target.has_monster()) {
@@ -278,7 +269,7 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
                 break;
             }
 
-            const Pos2D pos_opposite(pos_target.y + ddy[dir], pos_target.x + ddx[dir]);
+            const Pos2D pos_opposite(pos_target.y + ddy[*dir], pos_target.x + ddx[*dir]);
             const auto &grid_opposite = floor.get_grid(pos_opposite);
             if (player_can_enter(player_ptr, grid_opposite.feat, 0) && !is_trap(player_ptr, grid_opposite.feat) && !grid_opposite.m_idx) {
                 msg_print(nullptr);
@@ -296,15 +287,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_POISON);
@@ -325,15 +313,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            if (dir == 5) {
-                return std::nullopt;
-            }
-
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_ZANMA);
@@ -353,15 +338,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             auto &floor = *player_ptr->current_floor_ptr;
             const auto &grid = floor.get_grid(pos);
             if (grid.has_monster()) {
@@ -381,8 +363,8 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
                 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];
-                    neighbor.x += ddx[dir];
+                    neighbor.y += ddy[*dir];
+                    neighbor.x += ddx[*dir];
                     if (is_cave_empty_bold(player_ptr, neighbor.y, neighbor.x)) {
                         target = Pos2D(neighbor.y, neighbor.x);
                     } else {
@@ -439,15 +421,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_HAGAN);
@@ -473,15 +452,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_COLD);
@@ -502,15 +478,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            if (dir == 5) {
-                return std::nullopt;
-            }
-
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_KYUSHO);
@@ -530,15 +503,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_MAJIN);
@@ -559,15 +529,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_SUTEMI);
@@ -588,15 +555,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_ELEC);
@@ -637,7 +601,7 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
             short new_cut = current_cut < 300 ? current_cut + 300 : current_cut * 2;
             (void)BadStatusSetter(player_ptr).set_cut(new_cut);
             const auto &floor = *player_ptr->current_floor_ptr;
-            for (dir = 0; dir < 8; dir++) {
+            for (auto dir = 0; dir < 8; dir++) {
                 const auto pos = player_ptr->get_position();
                 const Pos2D pos_ddd(pos.y + ddy_ddd[dir], pos.x + ddx_ddd[dir]);
                 const auto &grid = floor.get_grid(pos_ddd);
@@ -666,15 +630,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_QUAKE);
@@ -695,6 +656,7 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         if (cast) {
             int total_damage = 0, basedam, i;
             ItemEntity *o_ptr;
+            int dir;
             if (!get_aim_dir(player_ptr, &dir)) {
                 return std::nullopt;
             }
@@ -755,16 +717,14 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
-                return std::nullopt;
-            }
-            if (dir == 5) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
             auto &floor = *player_ptr->current_floor_ptr;
             for (auto i = 0; i < 3; i++) {
-                const Pos2D pos = player_ptr->get_neighbor(dir);
+                const Pos2D pos = player_ptr->get_neighbor(*dir);
                 auto &grid = floor.get_grid(pos);
 
                 if (grid.has_monster()) {
@@ -783,7 +743,7 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
                     break;
                 }
 
-                const Pos2D pos_new(pos.y + ddy[dir], pos.x + ddx[dir]);
+                const Pos2D pos_new(pos.y + ddy[*dir], pos.x + ddx[*dir]);
                 const auto m_idx = grid.m_idx;
                 auto &monster = floor.m_list[m_idx];
 
@@ -836,15 +796,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            if (dir == 5) {
-                return std::nullopt;
-            }
-
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_DRAIN);
@@ -953,6 +910,7 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
+            int dir;
             if (!get_rep_dir(player_ptr, &dir)) {
                 return std::nullopt;
             }
@@ -981,15 +939,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            if (dir == 5) {
-                return std::nullopt;
-            }
-
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_dungeon_definition().flags.has(DungeonFeatureType::NO_MELEE)) {
                 msg_print(_("なぜか攻撃することができない。", "Something prevents you from attacking."));
@@ -1039,15 +994,12 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
         }
 
         if (cast) {
-            if (!get_direction(player_ptr, &dir)) {
+            const auto dir = get_direction(player_ptr);
+            if (!dir || (dir == 5)) {
                 return std::nullopt;
             }
 
-            if (dir == 5) {
-                return std::nullopt;
-            }
-
-            const auto pos = player_ptr->get_neighbor(dir);
+            const auto pos = player_ptr->get_neighbor(*dir);
             const auto &floor = *player_ptr->current_floor_ptr;
             if (floor.get_grid(pos).has_monster()) {
                 do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_UNDEAD);

diff --git a/src/specific-object/monster-ball.cpp b/src/specific-object/monster-ball.cpp
index 47d1c81..c93d80e 100644 (file)
--- a/src/specific-object/monster-ball.cpp
+++ b/src/specific-object/monster-ball.cpp
@@ -142,12 +142,12 @@ bool exe_monster_capture(PlayerType *player_ptr, ItemEntity &item)
         return true;
     }
 
-    DIRECTION dir;
-    if (!get_direction(player_ptr, &dir)) {
+    const auto dir = get_direction(player_ptr);
+    if (!dir) {
         return true;
     }
 
-    if (!release_monster(player_ptr, item, dir)) {
+    if (!release_monster(player_ptr, item, *dir)) {
         msg_print(_("おっと、解放に失敗した。", "Oops.  You failed to release your pet."));
     }
 

diff --git a/src/spell/spells-status.cpp b/src/spell/spells-status.cpp
index c000e24..7655774 100644 (file)
--- a/src/spell/spells-status.cpp
+++ b/src/spell/spells-status.cpp
@@ -533,13 +533,13 @@ bool restore_all_status(PlayerType *player_ptr)
 
 bool fishing(PlayerType *player_ptr)
 {
-    DIRECTION dir;
-    if (!get_direction(player_ptr, &dir)) {
+    const auto dir = get_direction(player_ptr);
+    if (!dir) {
         return false;
     }
 
-    const auto pos = player_ptr->get_neighbor(dir);
-    player_ptr->fishing_dir = dir;
+    const auto pos = player_ptr->get_neighbor(*dir);
+    player_ptr->fishing_dir = *dir;
     const auto &floor = *player_ptr->current_floor_ptr;
     if (!cave_has_flag_bold(&floor, pos.y, pos.x, TerrainCharacteristics::WATER)) {
         msg_print(_("そこは水辺ではない。", "You can't fish here."));

diff --git a/src/target/target-getter.cpp b/src/target/target-getter.cpp
index ded6014..c0fd0e1 100644 (file)
--- a/src/target/target-getter.cpp
+++ b/src/target/target-getter.cpp
@@ -114,7 +114,7 @@ bool get_aim_dir(PlayerType *player_ptr, int *dp)
     return true;
 }
 
-bool get_direction(PlayerType *player_ptr, int *dp)
+std::optional<int> get_direction(PlayerType *player_ptr)
 {
     auto dir = command_dir;
     short code;
@@ -122,12 +122,11 @@ bool get_direction(PlayerType *player_ptr, int *dp)
         dir = code;
     }
 
-    *dp = code;
     constexpr auto prompt = _("方向 (ESCで中断)? ", "Direction (Escape to cancel)? ");
     while (dir == 0) {
         const auto command = input_command(prompt, true);
         if (!command) {
-            return false;
+            return std::nullopt;
         }
 
         dir = get_keymap_dir(*command);
@@ -156,9 +155,8 @@ bool get_direction(PlayerType *player_ptr, int *dp)
         }
     }
 
-    *dp = dir;
     repeat_push(static_cast<short>(command_dir));
-    return true;
+    return dir;
 }
 
 /*

diff --git a/src/target/target-getter.h b/src/target/target-getter.h
index 63f34bc..d24b196 100644 (file)
--- a/src/target/target-getter.h
+++ b/src/target/target-getter.h
@@ -1,6 +1,8 @@
 #pragma once
 
+#include <optional>
+
 class PlayerType;
 bool get_aim_dir(PlayerType *player_ptr, int *dp);
-bool get_direction(PlayerType *player_ptr, int *dp);
+std::optional<int> get_direction(PlayerType *player_ptr);
 bool get_rep_dir(PlayerType *player_ptr, int *dp, bool under = false);