diff --git a/src/action/movement-execution.cpp b/src/action/movement-execution.cpp
index 4bc80055dd..ff5e2cc00b 100644
--- a/src/action/movement-execution.cpp
+++ b/src/action/movement-execution.cpp
@@ -291,7 +291,7 @@ void exe_movement(PlayerType *player_ptr, DIRECTION dir, bool do_pickup, bool br
                     energy.reset_player_turn();
                 }
             } else {
-                if (easy_open && is_closed_door(player_ptr, grid.get_feat_mimic()) && easy_open_door(player_ptr, pos.y, pos.x)) {
+                if (easy_open && floor.is_closed_door(pos, true) && easy_open_door(player_ptr, pos.y, pos.x)) {
                     return;
                 }
 
diff --git a/src/action/open-close-execution.cpp b/src/action/open-close-execution.cpp
index 718e2a05b5..29753c1cb3 100644
--- a/src/action/open-close-execution.cpp
+++ b/src/action/open-close-execution.cpp
@@ -150,12 +150,13 @@ bool exe_close(PlayerType *player_ptr, POSITION y, POSITION x)
 bool easy_open_door(PlayerType *player_ptr, POSITION y, POSITION x)
 {
     const Pos2D pos(y, x);
-    const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
-    const auto &terrain = grid.get_terrain();
-    if (!is_closed_door(player_ptr, grid.feat)) {
+    const auto &floor = *player_ptr->current_floor_ptr;
+    if (!floor.is_closed_door(pos)) {
         return false;
     }
 
+    const auto &grid = floor.get_grid(pos);
+    const auto &terrain = grid.get_terrain();
     if (terrain.flags.has_not(TerrainCharacteristics::OPEN)) {
         constexpr auto fmt = _("%sはがっちりと閉じられているようだ。", "The %s appears to be stuck.");
         msg_format(fmt, grid.get_terrain_mimic().name.data());
diff --git a/src/action/travel-execution.cpp b/src/action/travel-execution.cpp
index 1848134b57..5ee9ef98e3 100644
--- a/src/action/travel-execution.cpp
+++ b/src/action/travel-execution.cpp
@@ -39,10 +39,10 @@ static DIRECTION travel_test(PlayerType *player_ptr, DIRECTION prev_dir)
         return 0;
     }
 
-    auto *floor_ptr = player_ptr->current_floor_ptr;
-    if ((disturb_trap_detect || alert_trap_detect) && player_ptr->dtrap && !(floor_ptr->grid_array[player_ptr->y][player_ptr->x].info & CAVE_IN_DETECT)) {
+    auto &floor = *player_ptr->current_floor_ptr;
+    if ((disturb_trap_detect || alert_trap_detect) && player_ptr->dtrap && !(floor.grid_array[player_ptr->y][player_ptr->x].info & CAVE_IN_DETECT)) {
         player_ptr->dtrap = false;
-        if (!(floor_ptr->grid_array[player_ptr->y][player_ptr->x].info & CAVE_UNSAFE)) {
+        if (!(floor.grid_array[player_ptr->y][player_ptr->x].info & CAVE_UNSAFE)) {
             if (alert_trap_detect) {
                 msg_print(_("* 注意:この先はトラップの感知範囲外です！ *", "*Leaving trap detect region!*"));
             }
@@ -57,9 +57,9 @@ static DIRECTION travel_test(PlayerType *player_ptr, DIRECTION prev_dir)
     for (int i = -max; i <= max; i++) {
         DIRECTION dir = cycle[chome[prev_dir] + i];
         const auto pos = player_ptr->get_neighbor(dir);
-        const auto &grid = floor_ptr->get_grid(pos);
+        const auto &grid = floor.get_grid(pos);
         if (grid.has_monster()) {
-            const auto &monster = floor_ptr->m_list[grid.m_idx];
+            const auto &monster = floor.m_list[grid.m_idx];
             if (monster.ml) {
                 return 0;
             }
@@ -81,11 +81,11 @@ static DIRECTION travel_test(PlayerType *player_ptr, DIRECTION prev_dir)
     }
 
     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)) {
+    if (!easy_open && floor.is_closed_door(pos_new)) {
         return 0;
     }
 
+    const auto &grid = floor.get_grid(pos_new);
     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 aad33627af..9cbb30553f 100644
--- a/src/cmd-action/cmd-open-close.cpp
+++ b/src/cmd-action/cmd-open-close.cpp
@@ -105,8 +105,9 @@ void do_cmd_open(PlayerType *player_ptr)
     }
 
     PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
+    auto &floor = *player_ptr->current_floor_ptr;
     if (easy_open) {
-        const auto &[num_doors, pos_door] = count_dt(player_ptr, GridCountKind::CLOSED_DOOR, false);
+        const auto &[num_doors, pos_door] = floor.count_doors_traps(player_ptr->get_position(), GridCountKind::CLOSED_DOOR, false);
         const auto &[num_chests, pos_chest] = count_chests(player_ptr, false);
         if ((num_doors > 0) || (num_chests > 0)) {
             const auto pos = pos_chest == Pos2D(0, 0) ? pos_door : pos_chest;
@@ -125,7 +126,6 @@ void do_cmd_open(PlayerType *player_ptr)
 
     int dir;
     if (get_rep_dir(player_ptr, &dir, true)) {
-        auto &floor = *player_ptr->current_floor_ptr;
         const auto pos = player_ptr->get_neighbor(dir);
         const auto &grid = floor.get_grid(pos);
         const auto o_idx = chest_check(&floor, pos, false);
@@ -159,9 +159,10 @@ void do_cmd_close(PlayerType *player_ptr)
         return;
     }
 
+    const auto &floor = *player_ptr->current_floor_ptr;
     PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
     if (easy_open) {
-        const auto &[num_doors, pos] = count_dt(player_ptr, GridCountKind::OPEN, false);
+        const auto &[num_doors, pos] = floor.count_doors_traps(player_ptr->get_position(), GridCountKind::OPEN, false);
         if (num_doors == 1) {
             command_dir = coords_to_dir(player_ptr, pos.y, pos.x);
         }
@@ -177,7 +178,7 @@ void do_cmd_close(PlayerType *player_ptr)
     int dir;
     if (get_rep_dir(player_ptr, &dir)) {
         const auto pos = player_ptr->get_neighbor(dir);
-        const auto &grid = player_ptr->current_floor_ptr->get_grid(pos);
+        const auto &grid = floor.get_grid(pos);
         if (grid.get_terrain_mimic().flags.has_not(TerrainCharacteristics::CLOSE)) {
             msg_print(_("そこには閉じるものが見当たらない。", "You see nothing there to close."));
         } else if (grid.has_monster()) {
@@ -204,9 +205,10 @@ void do_cmd_disarm(PlayerType *player_ptr)
         return;
     }
 
+    auto &floor = *player_ptr->current_floor_ptr;
     PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
     if (easy_disarm) {
-        const auto &[num_traps, pos_trap] = count_dt(player_ptr, GridCountKind::TRAP, true);
+        const auto &[num_traps, pos_trap] = floor.count_doors_traps(player_ptr->get_position(), GridCountKind::TRAP, true);
         const auto &[num_chests, pos_chest] = count_chests(player_ptr, true);
         if ((num_traps > 0) || (num_chests > 0)) {
             const auto pos = pos_chest == Pos2D(0, 0) ? pos_trap : pos_chest;
@@ -226,12 +228,10 @@ void do_cmd_disarm(PlayerType *player_ptr)
     int dir;
     auto more = false;
     if (get_rep_dir(player_ptr, &dir, true)) {
-        auto &floor = *player_ptr->current_floor_ptr;
         const auto pos = player_ptr->get_neighbor(dir);
         const auto &grid = floor.get_grid(pos);
-        const auto feat = grid.get_feat_mimic();
         const auto o_idx = chest_check(&floor, pos, true);
-        if (!is_trap(player_ptr, feat) && !o_idx) {
+        if (!floor.is_trap(pos) && !o_idx) {
             msg_print(_("そこには解除するものが見当たらない。", "You see nothing there to disarm."));
         } else if (grid.has_monster() && !floor.m_list[grid.m_idx].is_riding()) {
             msg_print(_("モンスターが立ちふさがっている！", "There is a monster in the way!"));
diff --git a/src/cmd-action/cmd-travel.cpp b/src/cmd-action/cmd-travel.cpp
index adce94765a..ee2149f1f6 100644
--- a/src/cmd-action/cmd-travel.cpp
+++ b/src/cmd-action/cmd-travel.cpp
@@ -175,7 +175,7 @@ void do_cmd_travel(PlayerType *player_ptr)
     const auto &floor = *player_ptr->current_floor_ptr;
     const auto &grid = floor.get_grid(pos);
     const auto &terrain = grid.get_terrain();
-    const auto is_marked = any_bits(grid.info, CAVE_MARK);
+    const auto is_marked = grid.is_mark();
     const auto is_wall = terrain.flags.has_any_of({ TerrainCharacteristics::WALL, TerrainCharacteristics::CAN_DIG });
     const auto is_door = terrain.flags.has(TerrainCharacteristics::DOOR) && (grid.mimic > 0);
     if (is_marked && (is_wall || is_door)) {
diff --git a/src/effect/effect-feature.cpp b/src/effect/effect-feature.cpp
index ebceafa718..1fc7248156 100644
--- a/src/effect/effect-feature.cpp
+++ b/src/effect/effect-feature.cpp
@@ -178,7 +178,7 @@ bool affect_feature(PlayerType *player_ptr, MONSTER_IDX src_idx, POSITION r, POS
             }
         }
 
-        if (is_trap(player_ptr, grid.feat)) {
+        if (floor.is_trap(pos)) {
             if (known) {
                 msg_print(_("まばゆい閃光が走った！", "There is a bright flash of light!"));
                 obvious = true;
@@ -187,7 +187,7 @@ bool affect_feature(PlayerType *player_ptr, MONSTER_IDX src_idx, POSITION r, POS
             cave_alter_feat(player_ptr, y, x, TerrainCharacteristics::DISARM);
         }
 
-        if (is_closed_door(player_ptr, grid.feat) && terrain.power && terrain.flags.has(TerrainCharacteristics::OPEN)) {
+        if (floor.is_closed_door(pos) && terrain.power && terrain.flags.has(TerrainCharacteristics::OPEN)) {
             FEAT_IDX old_feat = grid.feat;
             cave_alter_feat(player_ptr, y, x, TerrainCharacteristics::DISARM);
             if (known && (old_feat != grid.feat)) {
@@ -206,7 +206,7 @@ bool affect_feature(PlayerType *player_ptr, MONSTER_IDX src_idx, POSITION r, POS
         break;
     }
     case AttributeType::KILL_DOOR: {
-        if (is_trap(player_ptr, grid.feat) || terrain.flags.has(TerrainCharacteristics::DOOR)) {
+        if (floor.is_trap(pos) || terrain.flags.has(TerrainCharacteristics::DOOR)) {
             if (known) {
                 msg_print(_("まばゆい閃光が走った！", "There is a bright flash of light!"));
                 obvious = true;
diff --git a/src/floor/floor-leaver.cpp b/src/floor/floor-leaver.cpp
index c2d8a36443..b8c9212f40 100644
--- a/src/floor/floor-leaver.cpp
+++ b/src/floor/floor-leaver.cpp
@@ -67,7 +67,7 @@ static bool check_pet_preservation_conditions(PlayerType *player_ptr, MonsterEnt
 
     const auto should_preserve = m_ptr->is_named();
     auto sight_from_player = player_ptr->current_floor_ptr->has_los(m_pos);
-    sight_from_player &= projectable(player_ptr, player_ptr->get_position(), m_ptr->get_position());
+    sight_from_player &= projectable(player_ptr, p_pos, m_pos);
     auto sight_from_monster = los(player_ptr, m_ptr->fy, m_ptr->fx, player_ptr->y, player_ptr->x);
     sight_from_monster &= projectable(player_ptr, m_pos, p_pos);
     if (should_preserve && (sight_from_player || sight_from_monster)) {
diff --git a/src/floor/floor-streams.cpp b/src/floor/floor-streams.cpp
index 5c2cd31f22..adbcd237c3 100644
--- a/src/floor/floor-streams.cpp
+++ b/src/floor/floor-streams.cpp
@@ -336,7 +336,7 @@ void build_streamer(PlayerType *player_ptr, FEAT_IDX feat, int chance)
                 if (!grid.is_extra() && !grid.is_inner() && !grid.is_outer() && !grid.is_solid()) {
                     continue;
                 }
-                if (is_closed_door(player_ptr, grid.feat)) {
+                if (floor.is_closed_door(pos)) {
                     continue;
                 }
             }
diff --git a/src/floor/floor-util.cpp b/src/floor/floor-util.cpp
index a135266cc1..d0be665e64 100644
--- a/src/floor/floor-util.cpp
+++ b/src/floor/floor-util.cpp
@@ -82,7 +82,7 @@ void update_smell(FloorType *floor_ptr, PlayerType *player_ptr)
             }
 
             auto &grid = floor_ptr->get_grid(pos);
-            auto update_when = !grid.cave_has_flag(TerrainCharacteristics::MOVE) && !is_closed_door(player_ptr, grid.feat);
+            auto update_when = !grid.cave_has_flag(TerrainCharacteristics::MOVE) && !floor_ptr->is_closed_door(pos);
             update_when |= !grid.has_los();
             update_when |= scent_adjust[i][j] == -1;
             if (update_when) {
diff --git a/src/floor/geometry.cpp b/src/floor/geometry.cpp
index 597f59ce81..512d8c8565 100644
--- a/src/floor/geometry.cpp
+++ b/src/floor/geometry.cpp
@@ -205,6 +205,6 @@ bool is_seen(PlayerType *player_ptr, MonsterEntity *m_ptr)
     auto is_inside_view = !ignore_unview;
     is_inside_view |= AngbandSystem::get_instance().is_phase_out();
     const auto m_pos = m_ptr->get_position();
-    is_inside_view |= player_can_see_bold(player_ptr, m_ptr->fy, m_ptr->fx) && projectable(player_ptr, player_ptr->get_position(), m_pos);
+    is_inside_view |= player_can_see_bold(player_ptr, m_pos.y, m_pos.x) && projectable(player_ptr, player_ptr->get_position(), m_pos);
     return m_ptr->ml && is_inside_view;
 }
diff --git a/src/grid/feature.cpp b/src/grid/feature.cpp
index f3a2f6e560..264f6c0599 100644
--- a/src/grid/feature.cpp
+++ b/src/grid/feature.cpp
@@ -104,32 +104,6 @@ FEAT_IDX feat_wall_inner;
 FEAT_IDX feat_wall_solid;
 FEAT_IDX feat_ground_type[100], feat_wall_type[100];
 
-/*!
- * @brief 地形が罠持ちであるかの判定を行う。 / Return TRUE if the given feature is a trap
- * @param feat 地形情報のID
- * @return 罠持ちの地形ならばTRUEを返す。
- */
-bool is_trap(PlayerType *player_ptr, FEAT_IDX feat)
-{
-    /* 関数ポインタの都合 */
-    (void)player_ptr;
-    return TerrainList::get_instance().get_terrain(feat).flags.has(TerrainCharacteristics::TRAP);
-}
-
-/*!
- * @brief 地形が閉じたドアであるかの判定を行う。 / Return TRUE if the given grid is a closed door
- * @param feat 地形情報のID
- * @return 閉じたドアのある地形ならばTRUEを返す。
- */
-bool is_closed_door(PlayerType *player_ptr, FEAT_IDX feat)
-{
-    /* 関数ポインタの都合 */
-    (void)player_ptr;
-    const auto &terrain = TerrainList::get_instance().get_terrain(feat);
-    return (terrain.flags.has(TerrainCharacteristics::OPEN) || terrain.flags.has(TerrainCharacteristics::BASH)) &&
-           terrain.flags.has_not(TerrainCharacteristics::MOVE);
-}
-
 /*
  * Not using graphical tiles for this feature?
  */
diff --git a/src/grid/feature.h b/src/grid/feature.h
index 85813b598f..ce43b896bf 100644
--- a/src/grid/feature.h
+++ b/src/grid/feature.h
@@ -64,8 +64,6 @@ extern FEAT_IDX feat_wall_type[100];
 
 class FloorType;
 class PlayerType;
-bool is_closed_door(PlayerType *player_ptr, FEAT_IDX feat);
-bool is_trap(PlayerType *player_ptr, FEAT_IDX feat);
 bool is_ascii_graphics(char x);
 FEAT_IDX feat_locked_door_random(int door_type);
 FEAT_IDX feat_jammed_door_random(int door_type);
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index fa555b3cde..6c4113aa0e 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -43,7 +43,6 @@
 #include "player/player-status.h"
 #include "room/rooms-builder.h"
 #include "system/dungeon-info.h"
-#include "system/enums/grid-count-kind.h"
 #include "system/enums/grid-flow.h"
 #include "system/floor-type-definition.h"
 #include "system/grid-type-definition.h"
@@ -154,7 +153,7 @@ bool new_player_spot(PlayerType *player_ptr)
  */
 bool is_hidden_door(PlayerType *player_ptr, const Grid &grid)
 {
-    return (grid.mimic || grid.cave_has_flag(TerrainCharacteristics::SECRET)) && is_closed_door(player_ptr, grid.feat);
+    return (grid.mimic || grid.cave_has_flag(TerrainCharacteristics::SECRET)) && player_ptr->current_floor_ptr->is_closed_door(player_ptr->get_position());
 }
 
 /*!
@@ -691,12 +690,12 @@ void update_flow(PlayerType *player_ptr)
                     continue;
                 }
 
-                auto &grid_neighbor = floor.get_grid(pos_neighbor);
-                if (is_closed_door(player_ptr, grid_neighbor.feat)) {
+                if (floor.is_closed_door(pos_neighbor)) {
                     m += 3;
                 }
 
                 /* Ignore "pre-stamped" entries */
+                auto &grid_neighbor = floor.get_grid(pos_neighbor);
                 auto &cost_neighbor = grid_neighbor.costs.at(gf);
                 auto &dist_neighbor = grid_neighbor.dists.at(gf);
                 if ((dist_neighbor != 0) && (dist_neighbor <= n) && (cost_neighbor <= m)) {
@@ -714,7 +713,7 @@ void update_flow(PlayerType *player_ptr)
                     break;
                 }
 
-                if (!can_move && !is_closed_door(player_ptr, grid_neighbor.feat)) {
+                if (!can_move && !floor.is_closed_door(pos_neighbor)) {
                     continue;
                 }
 
@@ -1037,40 +1036,6 @@ void set_cave_feat(FloorType *floor_ptr, POSITION y, POSITION x, FEAT_IDX featur
     floor_ptr->grid_array[y][x].feat = feature_idx;
 }
 
-/*!
- * @brief プレイヤーの周辺9マスに該当する地形がいくつあるかを返す
- * @param player_ptr プレイヤーへの参照ポインタ
- * @param gck 判定条件
- * @param under TRUEならばプレイヤーの直下の座標も走査対象にする
- * @return 該当する地形の数と、該当する地形の中から1つの座標
- */
-std::pair<int, Pos2D> count_dt(PlayerType *player_ptr, GridCountKind gck, bool under)
-{
-    auto count = 0;
-    Pos2D pos(0, 0);
-    const auto &floor = *player_ptr->current_floor_ptr;
-    for (auto d = 0; d < 9; d++) {
-        if ((d == 8) && !under) {
-            continue;
-        }
-
-        Pos2D pos_neighbor(player_ptr->y + ddy_ddd[d], player_ptr->x + ddx_ddd[d]);
-        const auto &grid = floor.get_grid(pos_neighbor);
-        if (!grid.is_mark()) {
-            continue;
-        }
-
-        if (!floor.check_terrain_state(pos_neighbor, gck)) {
-            continue;
-        }
-
-        ++count;
-        pos = pos_neighbor;
-    }
-
-    return { count, pos };
-}
-
 /*!
  * @brief マス構造体のspecial要素を利用する地形かどうかを判定する.
  */
diff --git a/src/grid/grid.h b/src/grid/grid.h
index d9b21ae07d..0d6501cf73 100644
--- a/src/grid/grid.h
+++ b/src/grid/grid.h
@@ -18,7 +18,6 @@
 #include "spell/spells-util.h"
 #include "system/angband.h"
 #include "util/point-2d.h"
-#include <utility>
 
 enum class AttributeType;
 class Grid;
@@ -87,7 +86,6 @@ bool darkened_grid(PlayerType *player_ptr, Grid *g_ptr);
 void delete_monster(PlayerType *player_ptr, POSITION y, POSITION x);
 void place_bold(PlayerType *player_ptr, POSITION y, POSITION x, grid_bold_type gh_type);
 void set_cave_feat(FloorType *floor_ptr, POSITION y, POSITION x, FEAT_IDX feature_idx);
-std::pair<int, Pos2D> count_dt(PlayerType *player_ptr, GridCountKind gck, bool under);
 void cave_lite_hack(FloorType *floor_ptr, POSITION y, POSITION x);
 void cave_redraw_later(FloorType *floor_ptr, POSITION y, POSITION x);
 void cave_note_and_redraw_later(FloorType *floor_ptr, POSITION y, POSITION x);
diff --git a/src/grid/trap.cpp b/src/grid/trap.cpp
index 63ca397235..04fa7218ae 100644
--- a/src/grid/trap.cpp
+++ b/src/grid/trap.cpp
@@ -625,7 +625,7 @@ void hit_trap(PlayerType *player_ptr, bool break_trap)
         break;
     }
 
-    if (break_trap && is_trap(player_ptr, grid.feat)) {
+    if (break_trap && floor.is_trap(p_pos)) {
         cave_alter_feat(player_ptr, p_pos.y, p_pos.x, TerrainCharacteristics::DISARM);
         msg_print(_("トラップを粉砕した。", "You destroyed the trap."));
     }
diff --git a/src/main-win.cpp b/src/main-win.cpp
index 9e5460d6f5..1250765192 100644
--- a/src/main-win.cpp
+++ b/src/main-win.cpp
@@ -923,10 +923,10 @@ static errr term_xtra_win_sound(int v)
 /*!
  * @brief Hack -- play a music
  */
-static errr term_xtra_win_music(int n, int v)
+static bool term_xtra_win_music(int n, int v)
 {
     if (!use_music) {
-        return 1;
+        return false;
     }
 
     return main_win_music::play_music(n, v);
@@ -935,14 +935,15 @@ static errr term_xtra_win_music(int n, int v)
 /*!
  * @brief Hack -- play a music matches a situation
  */
-static errr term_xtra_win_scene(int v)
+static bool term_xtra_win_scene(int v)
 {
     // TODO 場面に合った壁紙変更対応
     if (!use_music) {
-        return 1;
+        return false;
     }
 
-    return main_win_music::play_music_scene(v);
+    main_win_music::play_music_scene(v);
+    return true;
 }
 
 /*!
@@ -976,13 +977,13 @@ static errr term_xtra_win(int n, int v)
     case TERM_XTRA_MUSIC_QUEST:
     case TERM_XTRA_MUSIC_TOWN:
     case TERM_XTRA_MUSIC_MONSTER: {
-        return term_xtra_win_music(n, v);
-    }
-    case TERM_XTRA_MUSIC_MUTE: {
-        return main_win_music::stop_music();
+        return term_xtra_win_music(n, v) ? 0 : 1;
     }
+    case TERM_XTRA_MUSIC_MUTE:
+        main_win_music::stop_music();
+        return 0;
     case TERM_XTRA_SCENE: {
-        return term_xtra_win_scene(v);
+        return term_xtra_win_scene(v) ? 0 : 1;
     }
     case TERM_XTRA_SOUND: {
         return term_xtra_win_sound(v);
@@ -1880,14 +1881,16 @@ static void process_menus(PlayerType *player_ptr, WORD wCmd)
     case IDM_OPTIONS_MUSIC: {
         arg_music = !arg_music;
         use_music = arg_music;
-        if (use_music) {
-            init_music();
-            if (game_in_progress) {
-                select_floor_music(player_ptr);
-            }
-        } else {
+        if (!use_music) {
             main_win_music::stop_music();
+            break;
         }
+
+        init_music();
+        if (game_in_progress) {
+            select_floor_music(player_ptr);
+        }
+
         break;
     }
     case IDM_OPTIONS_MUSIC_VOLUME_100:
diff --git a/src/main-win/main-win-cfg-reader.cpp b/src/main-win/main-win-cfg-reader.cpp
index 7b562ced67..0e51ae1fc1 100644
--- a/src/main-win/main-win-cfg-reader.cpp
+++ b/src/main-win/main-win-cfg-reader.cpp
@@ -85,11 +85,10 @@ CfgData CfgReader::read_sections(std::initializer_list<cfg_section> sections) co
     const auto cfg_path_str = this->cfg_path.string();
 
     for (auto &section : sections) {
-        concptr read_key;
-        char key_buf[80]{};
-        for (auto index = 0; (read_key = section.key_at(index, key_buf)) != nullptr; ++index) {
+        std::optional<std::string> read_key;
+        for (auto index = 0; (read_key = section.key_at(index)) != std::nullopt; ++index) {
             char buf[MAIN_WIN_MAX_PATH]{};
-            if (GetPrivateProfileStringA(section.section_name, read_key, "", buf, MAIN_WIN_MAX_PATH, cfg_path_str.data()) == 0) {
+            if (GetPrivateProfileStringA(section.section_name.data(), read_key->data(), "", buf, MAIN_WIN_MAX_PATH, cfg_path_str.data()) == 0) {
                 continue;
             }
 
diff --git a/src/main-win/main-win-cfg-reader.h b/src/main-win/main-win-cfg-reader.h
index 1feb67a93f..635c4a236f 100644
--- a/src/main-win/main-win-cfg-reader.h
+++ b/src/main-win/main-win-cfg-reader.h
@@ -5,13 +5,13 @@
 #include <filesystem>
 #include <initializer_list>
 #include <optional>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
 typedef uint cfg_key;
 using cfg_values = std::vector<std::string>;
 using cfg_map = std::unordered_map<cfg_key, cfg_values>;
-using key_name_func = concptr (*)(int, char *);
 
 /*!
  * @brief .cfgファイルの読み取り対象とCfgData格納先のキー指定
@@ -25,14 +25,14 @@ using key_name_func = concptr (*)(int, char *);
 struct cfg_section {
 
     //! The name of the section in cfg file
-    concptr section_name;
+    std::string section_name;
     //! the "actions" value of "term_xtra()". see:z-term.h TERM_XTRA_xxxxx
     int action_type;
     /*!
      * Returns a reference to the name of the key at a specified action-val* in the section.
      * *action-val : the 2nd parameter of "term_xtra()"
      */
-    key_name_func key_at;
+    std::function<std::optional<std::string>(int)> key_at;
     //! 1つでもデータを読み込めた場合にtrueを設定する。（nullptrの場合を除く）
     bool *has_data = nullptr;
 };
diff --git a/src/main-win/main-win-music.cpp b/src/main-win/main-win-music.cpp
index d54b27b2c4..0d72f3258b 100644
--- a/src/main-win/main-win-music.cpp
+++ b/src/main-win/main-win-music.cpp
@@ -6,11 +6,13 @@
 #include "main-win/main-win-music.h"
 #include "dungeon/quest.h"
 #include "floor/floor-town.h"
+#include "main-win/main-win-cfg-reader.h"
 #include "main-win/main-win-define.h"
 #include "main-win/main-win-mci.h"
 #include "main-win/main-win-mmsystem.h"
 #include "main-win/main-win-tokenizer.h"
 #include "main-win/main-win-utils.h"
+#include "main/music-definitions-table.h"
 #include "main/scene-table.h"
 #include "main/sound-of-music.h"
 #include "system/dungeon-info.h"
@@ -21,6 +23,7 @@
 #include <algorithm>
 #include <digitalv.h>
 #include <limits>
+#include <string>
 
 bool use_pause_music_inactive = false;
 static int current_music_type = TERM_XTRA_MUSIC_MUTE;
@@ -46,12 +49,10 @@ namespace main_win_music {
  * @param buf 使用しない
  * @return 対応するキー名を返す
  */
-static concptr basic_key_at(int index, char *buf)
+static std::optional<std::string> basic_key_at(int index)
 {
-    (void)buf;
-
     if (index >= MUSIC_BASIC_MAX) {
-        return nullptr;
+        return std::nullopt;
     }
 
     return angband_music_basic_name[index];
@@ -63,14 +64,13 @@ static concptr basic_key_at(int index, char *buf)
  * @param buf バッファ
  * @return 対応するキー名を返す
  */
-static concptr dungeon_key_at(int index, char *buf)
+static std::optional<std::string> dungeon_key_at(int index)
 {
     if (index >= static_cast<int>(dungeons_info.size())) {
-        return nullptr;
+        return std::nullopt;
     }
 
-    sprintf(buf, "dungeon%03d", index);
-    return buf;
+    return format("dungeon%03d", index);
 }
 
 /*!
@@ -79,15 +79,14 @@ static concptr dungeon_key_at(int index, char *buf)
  * @param buf バッファ
  * @return 対応するキー名を返す
  */
-static concptr quest_key_at(int index, char *buf)
+static std::optional<std::string> quest_key_at(int index)
 {
     const auto &quests = QuestList::get_instance();
     if (index > enum2i(quests.rbegin()->first)) {
-        return nullptr;
+        return std::nullopt;
     }
 
-    sprintf(buf, "quest%03d", index);
-    return buf;
+    return format("quest%03d", index);
 }
 
 /*!
@@ -96,14 +95,13 @@ static concptr quest_key_at(int index, char *buf)
  * @param buf バッファ
  * @return 対応するキー名を返す
  */
-static concptr town_key_at(int index, char *buf)
+static std::optional<std::string> town_key_at(int index)
 {
     if (index >= static_cast<int>(towns_info.size())) {
-        return nullptr;
+        return std::nullopt;
     }
 
-    sprintf(buf, "town%03d", index);
-    return buf;
+    return format("town%03d", index);
 }
 
 /*!
@@ -112,14 +110,13 @@ static concptr town_key_at(int index, char *buf)
  * @param buf バッファ
  * @return 対応するキー名を返す
  */
-static concptr monster_key_at(int index, char *buf)
+static std::optional<std::string> monster_key_at(int index)
 {
-    if (index >= static_cast<int>(monraces_info.size())) {
-        return nullptr;
+    if (index >= static_cast<int>(MonraceList::get_instance().size())) {
+        return std::nullopt;
     }
 
-    sprintf(buf, "monster%04d", index);
-    return buf;
+    return format("monster%04d", index);
 }
 
 /*!
@@ -160,42 +157,42 @@ void load_music_prefs()
 /*
  * Stop a music
  */
-errr stop_music(void)
+void stop_music()
 {
     mciSendCommandW(mci_open_parms.wDeviceID, MCI_STOP, MCI_WAIT, 0);
     mciSendCommandW(mci_open_parms.wDeviceID, MCI_CLOSE, MCI_WAIT, 0);
     current_music_type = TERM_XTRA_MUSIC_MUTE;
     current_music_id = 0;
     current_music_path = "";
-    return 0;
 }
 
 /*
  * Play a music
  */
-errr play_music(int type, int val)
+bool play_music(int type, int val)
 {
     if (type == TERM_XTRA_MUSIC_MUTE) {
-        return stop_music();
+        stop_music();
+        return true;
     }
 
     if (current_music_type == type && current_music_id == val) {
-        return 0;
+        return true;
     } // now playing
 
     if (!music_cfg_data) {
-        return 1;
+        return false;
     }
 
     auto filename = music_cfg_data->get_rand(type, val);
     if (!filename) {
-        return 1;
+        return false;
     } // no setting
 
     auto path_music = path_build(ANGBAND_DIR_XTRA_MUSIC, *filename);
     if (current_music_type != TERM_XTRA_MUSIC_MUTE) {
         if (current_music_path == path_music) {
-            return 0;
+            return true;
         }
     } // now playing same file
 
@@ -210,7 +207,7 @@ errr play_music(int type, int val)
     mciSendCommandW(mci_open_parms.wDeviceID, MCI_CLOSE, MCI_WAIT, 0);
     mciSendCommandW(mci_open_parms.wDeviceID, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_ELEMENT | MCI_NOTIFY, (DWORD)&mci_open_parms);
     // Send MCI_PLAY in the notification event once MCI_OPEN is completed
-    return 0;
+    return true;
 }
 
 /*
@@ -232,18 +229,15 @@ void resume_music(void)
 /*
  * Play a music matches a situation
  */
-errr play_music_scene(int val)
+void play_music_scene(int val)
 {
     // リストの先頭から順に再生を試み、再生できたら抜ける
     auto &list = get_scene_type_list(val);
-    const errr err_sucsess = 0;
     for (auto &item : list) {
-        if (play_music(item.type, item.val) == err_sucsess) {
+        if (play_music(item.type, item.val)) {
             break;
         }
     }
-
-    return 0;
 }
 
 void set_music_volume(int volume)
diff --git a/src/main-win/main-win-music.h b/src/main-win/main-win-music.h
index 9dc4f4ef4f..d66cf2342c 100644
--- a/src/main-win/main-win-music.h
+++ b/src/main-win/main-win-music.h
@@ -1,22 +1,20 @@
 #pragma once
 
-#include "main-win/main-win-cfg-reader.h"
-#include "main/music-definitions-table.h"
-#include "system/h-type.h"
 #include <array>
 #include <filesystem>
 #include <optional>
 #include <windows.h>
 
+class CfgData;
 extern bool use_pause_music_inactive;
 extern std::filesystem::path ANGBAND_DIR_XTRA_MUSIC;
 extern std::optional<CfgData> music_cfg_data;
 
 namespace main_win_music {
 void load_music_prefs();
-errr stop_music();
-errr play_music(int type, int val);
-errr play_music_scene(int val);
+void stop_music();
+bool play_music(int type, int val);
+void play_music_scene(int val);
 void pause_music();
 void resume_music();
 void set_music_volume(int volume);
diff --git a/src/main-win/main-win-sound.cpp b/src/main-win/main-win-sound.cpp
index d624397c74..0790a9a948 100644
--- a/src/main-win/main-win-sound.cpp
+++ b/src/main-win/main-win-sound.cpp
@@ -187,12 +187,10 @@ static bool play_sound_impl(const std::filesystem::path &path, int volume)
  * @param buf 使用しない
  * @return 対応するキー名を返す
  */
-static concptr sound_key_at(int index, char *buf)
+static std::optional<std::string> sound_key_at(int index)
 {
-    (void)buf;
-
     if (index >= SOUND_MAX) {
-        return nullptr;
+        return std::nullopt;
     }
 
     return angband_sound_name[index];
diff --git a/src/main-win/main-win-utils.h b/src/main-win/main-win-utils.h
index ad3149062a..66e4c83e7b 100644
--- a/src/main-win/main-win-utils.h
+++ b/src/main-win/main-win-utils.h
@@ -4,7 +4,6 @@
  * @brief Windows版固有実装(ユーティリティー)ヘッダ
  */
 
-#include "system/angband.h"
 #include <filesystem>
 #include <optional>
 #include <string>
diff --git a/src/mind/mind-berserker.cpp b/src/mind/mind-berserker.cpp
index 4d047971a1..6f568b83c2 100644
--- a/src/mind/mind-berserker.cpp
+++ b/src/mind/mind-berserker.cpp
@@ -48,13 +48,13 @@ bool cast_berserk_spell(PlayerType *player_ptr, MindBerserkerType spell)
         }
 
         do_cmd_attack(player_ptr, pos.y, pos.x, HISSATSU_NONE);
-        if (!player_can_enter(player_ptr, grid.feat, 0) || is_trap(player_ptr, grid.feat)) {
+        if (!player_can_enter(player_ptr, grid.feat, 0) || floor.is_trap(pos)) {
             return true;
         }
 
-        const Pos2D pos_new(pos.y + ddy[*dir], pos.x + ddx[*dir]);
+        const auto pos_new = pos + Pos2DVec(ddy[*dir], 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()) {
+        if (player_can_enter(player_ptr, grid_new.feat, 0) && !floor.is_trap(pos_new) && !grid_new.has_monster()) {
             msg_print(nullptr);
             (void)move_player_effect(player_ptr, pos_new.y, pos_new.x, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
         }
diff --git a/src/monster-floor/monster-direction.cpp b/src/monster-floor/monster-direction.cpp
index b925bec85a..efeb2e2be6 100644
--- a/src/monster-floor/monster-direction.cpp
+++ b/src/monster-floor/monster-direction.cpp
@@ -30,7 +30,6 @@
  */
 static bool decide_pet_approch_direction(PlayerType *player_ptr, const MonsterEntity &monster_from, const MonsterEntity &monster_to)
 {
-    const auto &monrace = monster_from.get_monrace();
     if (!monster_from.is_pet()) {
         return false;
     }
@@ -43,6 +42,7 @@ static bool decide_pet_approch_direction(PlayerType *player_ptr, const MonsterEn
         return true;
     }
 
+    const auto &monrace = monster_from.get_monrace();
     return monrace.aaf < monster_to.cdis;
 }
 
@@ -83,12 +83,14 @@ static void decide_enemy_approch_direction(PlayerType *player_ptr, MONSTER_IDX m
 
         const auto can_pass_wall = monrace.feature_flags.has(MonsterFeatureType::PASS_WALL) && (!monster_from.is_riding() || has_pass_wall(player_ptr));
         const auto can_kill_wall = monrace.feature_flags.has(MonsterFeatureType::KILL_WALL) && !monster_from.is_riding();
+        const auto m_pos_from = monster_from.get_position();
+        const auto m_pos_to = monster_to.get_position();
         if (can_pass_wall || can_kill_wall) {
-            if (!in_disintegration_range(&floor, monster_from.fy, monster_from.fx, monster_to.fy, monster_to.fx)) {
+            if (!in_disintegration_range(&floor, m_pos_from.y, m_pos_from.x, m_pos_to.y, m_pos_to.x)) {
                 continue;
             }
         } else {
-            if (!projectable(player_ptr, monster_from.get_position(), monster_to.get_position())) {
+            if (!projectable(player_ptr, m_pos_from, m_pos_to)) {
                 continue;
             }
         }
diff --git a/src/monster-floor/monster-move.cpp b/src/monster-floor/monster-move.cpp
index 4d720f444a..31cae14897 100644
--- a/src/monster-floor/monster-move.cpp
+++ b/src/monster-floor/monster-move.cpp
@@ -190,11 +190,11 @@ static bool process_door(PlayerType *player_ptr, turn_flags *turn_flags_ptr, con
 {
     auto &monrace = monster.get_monrace();
     const auto &floor = *player_ptr->current_floor_ptr;
-    const auto &grid = floor.get_grid(pos);
-    if (!is_closed_door(player_ptr, grid.feat)) {
+    if (!floor.is_closed_door(pos)) {
         return true;
     }
 
+    const auto &grid = floor.get_grid(pos);
     auto &terrain = grid.get_terrain();
     auto may_bash = bash_normal_door(player_ptr, turn_flags_ptr, monster, pos);
     bash_glass_door(player_ptr, turn_flags_ptr, monster, terrain, may_bash);
diff --git a/src/monster-floor/monster-sweep-grid.cpp b/src/monster-floor/monster-sweep-grid.cpp
index 11cfb9e8e1..a914dc852b 100644
--- a/src/monster-floor/monster-sweep-grid.cpp
+++ b/src/monster-floor/monster-sweep-grid.cpp
@@ -373,8 +373,7 @@ bool MonsterSweepGrid::is_best_cost(const Pos2D &pos, const int now_cost)
             return false;
         }
 
-        const auto &grid = floor.get_grid(pos);
-        if (!this->can_open_door && is_closed_door(this->player_ptr, grid.feat)) {
+        if (!this->can_open_door && floor.is_closed_door(pos)) {
             return false;
         }
     }
diff --git a/src/monster/monster-update.cpp b/src/monster/monster-update.cpp
index 68c7074501..90ba3fe7c2 100644
--- a/src/monster/monster-update.cpp
+++ b/src/monster/monster-update.cpp
@@ -489,11 +489,11 @@ static void update_invisible_monster(PlayerType *player_ptr, um_type *um_ptr, MO
     }
 
     if (!player_ptr->effects()->hallucination().is_hallucinated()) {
-        auto *r_ptr = &monster.get_monrace();
+        auto &monrace = monster.get_monrace();
         if ((monster.ap_r_idx == MonraceId::KAGE) && (monraces_info[MonraceId::KAGE].r_sights < MAX_SHORT)) {
             monraces_info[MonraceId::KAGE].r_sights++;
-        } else if (monster.is_original_ap() && (r_ptr->r_sights < MAX_SHORT)) {
-            r_ptr->r_sights++;
+        } else if (monster.is_original_ap() && (monrace.r_sights < MAX_SHORT)) {
+            monrace.r_sights++;
         }
     }
 
diff --git a/src/mspell/mspell-lite.cpp b/src/mspell/mspell-lite.cpp
index 631676f808..3374e63948 100644
--- a/src/mspell/mspell-lite.cpp
+++ b/src/mspell/mspell-lite.cpp
@@ -132,8 +132,10 @@ static void check_lite_area_by_mspell(PlayerType *player_ptr, msa_type *msa_ptr)
     const auto &system = AngbandSystem::get_instance();
     auto light_by_disintegration = msa_ptr->ability_flags.has(MonsterAbilityType::BR_DISI);
     light_by_disintegration &= msa_ptr->m_ptr->cdis < system.get_max_range() / 2;
-    light_by_disintegration &= in_disintegration_range(player_ptr->current_floor_ptr, msa_ptr->m_ptr->fy, msa_ptr->m_ptr->fx, msa_ptr->y, msa_ptr->x);
-    light_by_disintegration &= one_in_(10) || (projectable(player_ptr, msa_ptr->get_position(), msa_ptr->m_ptr->get_position()) && one_in_(2));
+    const auto pos = msa_ptr->get_position();
+    const auto m_pos = msa_ptr->m_ptr->get_position();
+    light_by_disintegration &= in_disintegration_range(player_ptr->current_floor_ptr, m_pos.y, m_pos.x, pos.y, pos.x);
+    light_by_disintegration &= one_in_(10) || (projectable(player_ptr, pos, m_pos) && one_in_(2));
     if (light_by_disintegration) {
         msa_ptr->do_spell = DO_SPELL_BR_DISI;
         msa_ptr->success = true;
@@ -142,7 +144,7 @@ static void check_lite_area_by_mspell(PlayerType *player_ptr, msa_type *msa_ptr)
 
     auto light_by_lite = msa_ptr->ability_flags.has(MonsterAbilityType::BR_LITE);
     light_by_lite &= msa_ptr->m_ptr->cdis < system.get_max_range() / 2;
-    light_by_lite &= los(player_ptr, msa_ptr->m_ptr->fy, msa_ptr->m_ptr->fx, msa_ptr->y, msa_ptr->x);
+    light_by_lite &= los(player_ptr, m_pos.y, m_pos.x, msa_ptr->y, msa_ptr->x);
     light_by_lite &= one_in_(5);
     if (light_by_lite) {
         msa_ptr->do_spell = DO_SPELL_BR_LITE;
@@ -156,8 +158,8 @@ static void check_lite_area_by_mspell(PlayerType *player_ptr, msa_type *msa_ptr)
 
     auto by = msa_ptr->y;
     auto bx = msa_ptr->x;
-    get_project_point(player_ptr, msa_ptr->m_ptr->fy, msa_ptr->m_ptr->fx, &by, &bx, 0L);
-    if ((distance(by, bx, msa_ptr->y, msa_ptr->x) <= 3) && los(player_ptr, by, bx, msa_ptr->y, msa_ptr->x) && one_in_(5)) {
+    get_project_point(player_ptr, m_pos.y, m_pos.x, &by, &bx, 0L);
+    if ((distance(by, bx, pos.y, pos.x) <= 3) && los(player_ptr, by, bx, pos.y, pos.x) && one_in_(5)) {
         msa_ptr->do_spell = DO_SPELL_BA_LITE;
         msa_ptr->success = true;
     }
diff --git a/src/object/warning.cpp b/src/object/warning.cpp
index 97c0b0c8d5..29e65ad6f8 100644
--- a/src/object/warning.cpp
+++ b/src/object/warning.cpp
@@ -541,8 +541,7 @@ bool process_warning(PlayerType *player_ptr, POSITION xx, POSITION yy)
         old_damage = old_damage / 2;
     }
 
-    auto *g_ptr = &floor.grid_array[yy][xx];
-    bool is_warning = (!easy_disarm && is_trap(player_ptr, g_ptr->feat)) || (g_ptr->mimic && is_trap(player_ptr, g_ptr->feat));
+    auto is_warning = (!easy_disarm || floor.get_grid(pos).mimic) && floor.is_trap(pos);
     is_warning &= !one_in_(13);
     if (!is_warning) {
         return true;
diff --git a/src/player/player-move.cpp b/src/player/player-move.cpp
index 42a3a20726..6aa0ed8ce3 100644
--- a/src/player/player-move.cpp
+++ b/src/player/player-move.cpp
@@ -67,7 +67,7 @@ static void discover_hidden_things(PlayerType *player_ptr, const Pos2D &pos)
 {
     auto &floor = *player_ptr->current_floor_ptr;
     const auto &grid = floor.get_grid(pos);
-    if (grid.mimic && is_trap(player_ptr, grid.feat)) {
+    if (grid.mimic && floor.is_trap(pos)) {
         disclose_grid(player_ptr, pos.y, pos.x);
         msg_print(_("トラップを発見した。", "You have found a trap."));
         disturb(player_ptr, false, true);
@@ -183,7 +183,7 @@ bool move_player_effect(PlayerType *player_ptr, POSITION ny, POSITION nx, BIT_FL
             SubWindowRedrawingFlag::DUNGEON,
         };
         rfu.set_flags(flags_swrf);
-        if ((!player_ptr->effects()->blindness().is_blind() && !no_lite(player_ptr)) || !is_trap(player_ptr, grid_new.feat)) {
+        if ((!player_ptr->effects()->blindness().is_blind() && !no_lite(player_ptr)) || !floor.is_trap(pos_new)) {
             grid_new.info &= ~(CAVE_UNSAFE);
         }
 
diff --git a/src/realm/realm-hissatsu.cpp b/src/realm/realm-hissatsu.cpp
index 50572359d8..8ef16a0166 100644
--- a/src/realm/realm-hissatsu.cpp
+++ b/src/realm/realm-hissatsu.cpp
@@ -185,13 +185,13 @@ std::optional<std::string> do_hissatsu_spell(PlayerType *player_ptr, SPELL_IDX s
             }
 
             do_cmd_attack(player_ptr, pos_target.y, pos_target.x, HISSATSU_NONE);
-            if (!player_can_enter(player_ptr, grid_target.feat, 0) || is_trap(player_ptr, grid_target.feat)) {
+            if (!player_can_enter(player_ptr, grid_target.feat, 0) || floor.is_trap(pos_target)) {
                 break;
             }
 
-            const Pos2D pos_opposite(pos_target.y + ddy[*dir], pos_target.x + ddx[*dir]);
+            const auto pos_opposite = pos_target + Pos2DVec(ddy[*dir], 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) {
+            if (player_can_enter(player_ptr, grid_opposite.feat, 0) && !floor.is_trap(pos_opposite) && !grid_opposite.m_idx) {
                 msg_print(nullptr);
                 (void)move_player_effect(player_ptr, pos_opposite.y, pos_opposite.x, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
             }
diff --git a/src/room/rooms-special.cpp b/src/room/rooms-special.cpp
index 6aec8441e1..c5bd2b0f9d 100644
--- a/src/room/rooms-special.cpp
+++ b/src/room/rooms-special.cpp
@@ -131,9 +131,9 @@ bool build_type15(PlayerType *player_ptr, dun_data_type *dd_ptr)
         const auto y = yval + 2 * ddy_ddd[dir1];
         const auto x = xval + 2 * ddx_ddd[dir1];
         place_secret_door(player_ptr, y, x, DOOR_GLASS_DOOR);
-        auto &grid = floor.get_grid({ y, x });
-        if (is_closed_door(player_ptr, grid.feat)) {
-            grid.mimic = feat_glass_wall;
+        const Pos2D pos(y, x);
+        if (floor.is_closed_door(pos)) {
+            floor.get_grid(pos).mimic = feat_glass_wall;
         }
 
         /* Place a potion */
diff --git a/src/room/rooms-vault.cpp b/src/room/rooms-vault.cpp
index 311694478b..83f6ffc415 100644
--- a/src/room/rooms-vault.cpp
+++ b/src/room/rooms-vault.cpp
@@ -309,9 +309,9 @@ static void build_vault(
             auto j = dy;
 
             /* Flip / rotate */
-            const auto pos = coord_trans({ j, i }, { yoffset, xoffset }, transno);
-            i = pos.x;
-            j = pos.y;
+            const auto pos_trans = coord_trans({ j, i }, { yoffset, xoffset }, transno);
+            i = pos_trans.x;
+            j = pos_trans.y;
             int x;
             int y;
             if (transno % 2 == 0) {
@@ -329,7 +329,8 @@ static void build_vault(
                 continue;
             }
 
-            auto &grid = floor.grid_array[y][x];
+            const Pos2D pos(y, x);
+            auto &grid = floor.get_grid(pos);
 
             /* Lay down a floor */
             place_grid(player_ptr, &grid, GB_FLOOR);
@@ -372,15 +373,15 @@ static void build_vault(
                 /* Treasure/trap */
             case '*':
                 if (evaluate_percent(75)) {
-                    place_object(player_ptr, y, x, 0L);
+                    place_object(player_ptr, pos.y, pos.x, 0L);
                 } else {
-                    place_trap(&floor, y, x);
+                    place_trap(&floor, pos.y, pos.x);
                 }
                 break;
 
                 /* Treasure */
             case '[':
-                place_object(player_ptr, y, x, 0L);
+                place_object(player_ptr, pos.y, pos.x, 0L);
                 break;
 
                 /* Tree */
@@ -390,115 +391,116 @@ static void build_vault(
 
                 /* Secret doors */
             case '+':
-                place_secret_door(player_ptr, y, x, DOOR_DEFAULT);
+                place_secret_door(player_ptr, pos.y, pos.x, DOOR_DEFAULT);
                 break;
 
                 /* Secret glass doors */
             case '-':
-                place_secret_door(player_ptr, y, x, DOOR_GLASS_DOOR);
-                if (is_closed_door(player_ptr, grid.feat)) {
+                place_secret_door(player_ptr, pos.y, pos.x, DOOR_GLASS_DOOR);
+                if (floor.is_closed_door(pos)) {
                     grid.mimic = feat_glass_wall;
                 }
+
                 break;
 
                 /* Curtains */
             case '\'':
-                place_secret_door(player_ptr, y, x, DOOR_CURTAIN);
+                place_secret_door(player_ptr, pos.y, pos.x, DOOR_CURTAIN);
                 break;
 
                 /* Trap */
             case '^':
-                place_trap(&floor, y, x);
+                place_trap(&floor, pos.y, pos.x);
                 break;
 
                 /* Black market in a dungeon */
             case 'S':
-                set_cave_feat(&floor, y, x, feat_black_market);
+                set_cave_feat(&floor, pos.y, pos.x, feat_black_market);
                 store_init(VALID_TOWNS, StoreSaleType::BLACK);
                 break;
 
                 /* The Pattern */
             case 'p':
-                set_cave_feat(&floor, y, x, feat_pattern_start);
+                set_cave_feat(&floor, pos.y, pos.x, feat_pattern_start);
                 break;
 
             case 'a':
-                set_cave_feat(&floor, y, x, feat_pattern_1);
+                set_cave_feat(&floor, pos.y, pos.x, feat_pattern_1);
                 break;
 
             case 'b':
-                set_cave_feat(&floor, y, x, feat_pattern_2);
+                set_cave_feat(&floor, pos.y, pos.x, feat_pattern_2);
                 break;
 
             case 'c':
-                set_cave_feat(&floor, y, x, feat_pattern_3);
+                set_cave_feat(&floor, pos.y, pos.x, feat_pattern_3);
                 break;
 
             case 'd':
-                set_cave_feat(&floor, y, x, feat_pattern_4);
+                set_cave_feat(&floor, pos.y, pos.x, feat_pattern_4);
                 break;
 
             case 'P':
-                set_cave_feat(&floor, y, x, feat_pattern_end);
+                set_cave_feat(&floor, pos.y, pos.x, feat_pattern_end);
                 break;
 
             case 'B':
-                set_cave_feat(&floor, y, x, feat_pattern_exit);
+                set_cave_feat(&floor, pos.y, pos.x, feat_pattern_exit);
                 break;
 
             case 'A':
                 /* Reward for Pattern walk */
                 floor.object_level = floor.base_level + 12;
-                place_object(player_ptr, y, x, AM_GOOD | AM_GREAT);
+                place_object(player_ptr, pos.y, pos.x, AM_GOOD | AM_GREAT);
                 floor.object_level = floor.base_level;
                 break;
 
             case '~':
-                set_cave_feat(&floor, y, x, feat_shallow_water);
+                set_cave_feat(&floor, pos.y, pos.x, feat_shallow_water);
                 break;
 
             case '=':
-                set_cave_feat(&floor, y, x, feat_deep_water);
+                set_cave_feat(&floor, pos.y, pos.x, feat_deep_water);
                 break;
 
             case 'v':
-                set_cave_feat(&floor, y, x, feat_shallow_lava);
+                set_cave_feat(&floor, pos.y, pos.x, feat_shallow_lava);
                 break;
 
             case 'w':
-                set_cave_feat(&floor, y, x, feat_deep_lava);
+                set_cave_feat(&floor, pos.y, pos.x, feat_deep_lava);
                 break;
 
             case 'f':
-                set_cave_feat(&floor, y, x, feat_shallow_acid_puddle);
+                set_cave_feat(&floor, pos.y, pos.x, feat_shallow_acid_puddle);
                 break;
 
             case 'F':
-                set_cave_feat(&floor, y, x, feat_deep_acid_puddle);
+                set_cave_feat(&floor, pos.y, pos.x, feat_deep_acid_puddle);
                 break;
 
             case 'g':
-                set_cave_feat(&floor, y, x, feat_shallow_poisonous_puddle);
+                set_cave_feat(&floor, pos.y, pos.x, feat_shallow_poisonous_puddle);
                 break;
 
             case 'G':
-                set_cave_feat(&floor, y, x, feat_deep_poisonous_puddle);
+                set_cave_feat(&floor, pos.y, pos.x, feat_deep_poisonous_puddle);
                 break;
 
             case 'h':
-                set_cave_feat(&floor, y, x, feat_cold_zone);
+                set_cave_feat(&floor, pos.y, pos.x, feat_cold_zone);
                 break;
 
             case 'H':
-                set_cave_feat(&floor, y, x, feat_heavy_cold_zone);
+                set_cave_feat(&floor, pos.y, pos.x, feat_heavy_cold_zone);
                 break;
 
             case 'i':
-                set_cave_feat(&floor, y, x, feat_electrical_zone);
+                set_cave_feat(&floor, pos.y, pos.x, feat_electrical_zone);
                 break;
 
             case 'I':
-                set_cave_feat(&floor, y, x, feat_heavy_electrical_zone);
+                set_cave_feat(&floor, pos.y, pos.x, feat_heavy_electrical_zone);
                 break;
             }
         }
diff --git a/src/store/cmd-store.cpp b/src/store/cmd-store.cpp
index c94d9689fa..5c6aaf6c72 100644
--- a/src/store/cmd-store.cpp
+++ b/src/store/cmd-store.cpp
@@ -158,7 +158,7 @@ void do_cmd_store(PlayerType *player_ptr)
         handle_stuff(player_ptr);
         if (player_ptr->inventory_list[INVEN_PACK].bi_id) {
             INVENTORY_IDX i_idx = INVEN_PACK;
-            auto *o_ptr = &player_ptr->inventory_list[i_idx];
+            const auto &item_inventory = player_ptr->inventory_list[i_idx];
             if (store_num != StoreSaleType::HOME) {
                 if (store_num == StoreSaleType::MUSEUM) {
                     msg_print(_("ザックからアイテムがあふれそうなので、あわてて博物館から出た...", "Your pack is so full that you flee the Museum..."));
@@ -167,22 +167,17 @@ void do_cmd_store(PlayerType *player_ptr)
                 }
 
                 leave_store = true;
-            } else if (!store_check_num(o_ptr, store_num)) {
+            } else if (!store_check_num(&item_inventory, store_num)) {
                 msg_print(_("ザックからアイテムがあふれそうなので、あわてて家から出た...", "Your pack is so full that you flee your home..."));
                 leave_store = true;
             } else {
-                int item_pos;
-                ItemEntity forge;
-                ItemEntity *q_ptr;
                 msg_print(_("ザックからアイテムがあふれてしまった！", "Your pack overflows!"));
-                q_ptr = &forge;
-                q_ptr->copy_from(o_ptr);
-                const auto item_name = describe_flavor(player_ptr, *q_ptr, 0);
+                ItemEntity item = item_inventory;
+                const auto item_name = describe_flavor(player_ptr, item, 0);
                 msg_format(_("%sが落ちた。(%c)", "You drop %s (%c)."), item_name.data(), index_to_label(i_idx));
                 vary_item(player_ptr, i_idx, -255);
                 handle_stuff(player_ptr);
-
-                item_pos = home_carry(player_ptr, q_ptr, store_num);
+                const auto item_pos = home_carry(player_ptr, &item, store_num);
                 if (item_pos >= 0) {
                     store_top = (item_pos / store_bottom) * store_bottom;
                     display_store_inventory(player_ptr, store_num);
diff --git a/src/store/store-util.cpp b/src/store/store-util.cpp
index c0a0747394..08fd8af861 100644
--- a/src/store/store-util.cpp
+++ b/src/store/store-util.cpp
@@ -107,7 +107,7 @@ std::vector<short> store_same_magic_device_pvals(ItemEntity *j_ptr)
  * See "object_similar()" for the same function for the "player"
  * </pre>
  */
-bool store_object_similar(ItemEntity *o_ptr, ItemEntity *j_ptr)
+bool store_object_similar(const ItemEntity *o_ptr, const ItemEntity *j_ptr)
 {
     if (o_ptr == j_ptr) {
         return false;
diff --git a/src/store/store-util.h b/src/store/store-util.h
index 0c0ad9191d..bc7d2b9989 100644
--- a/src/store/store-util.h
+++ b/src/store/store-util.h
@@ -57,4 +57,4 @@ std::vector<short> store_same_magic_device_pvals(ItemEntity *j_ptr);
 void store_item_increase(short i_idx, int item_num);
 void store_item_optimize(short i_idx);
 int store_carry(ItemEntity *o_ptr);
-bool store_object_similar(ItemEntity *o_ptr, ItemEntity *j_ptr);
+bool store_object_similar(const ItemEntity *o_ptr, const ItemEntity *j_ptr);
diff --git a/src/store/store.cpp b/src/store/store.cpp
index 563eabac5b..907a059a0a 100644
--- a/src/store/store.cpp
+++ b/src/store/store.cpp
@@ -102,7 +102,7 @@ static int check_free_space(StoreSaleType store_num)
  *  1 : Cannot be combined but there are empty spaces.
  * </pre>
  */
-int store_check_num(ItemEntity *o_ptr, StoreSaleType store_num)
+int store_check_num(const ItemEntity *o_ptr, StoreSaleType store_num)
 {
     if ((store_num == StoreSaleType::HOME) || (store_num == StoreSaleType::MUSEUM)) {
         bool old_stack_force_notes = stack_force_notes;
diff --git a/src/store/store.h b/src/store/store.h
index 1a422b686a..9c37d0d9e3 100644
--- a/src/store/store.h
+++ b/src/store/store.h
@@ -30,5 +30,5 @@ void store_shuffle(PlayerType *player_ptr, StoreSaleType which);
 void store_maintenance(PlayerType *player_ptr, int town_num, StoreSaleType store_num, int chance);
 void store_init(int town_num, StoreSaleType store_num);
 void store_examine(PlayerType *player_ptr, StoreSaleType store_num);
-int store_check_num(ItemEntity *o_ptr, StoreSaleType store_num);
+int store_check_num(const ItemEntity *o_ptr, StoreSaleType store_num);
 std::optional<short> input_stock(std::string_view fmt, int min, int max, StoreSaleType store_num);
diff --git a/src/system/artifact-type-definition.cpp b/src/system/artifact-type-definition.cpp
index 46934fb210..d2b8fffbee 100644
--- a/src/system/artifact-type-definition.cpp
+++ b/src/system/artifact-type-definition.cpp
@@ -1,6 +1,7 @@
 #include "system/artifact-type-definition.h"
 #include "artifact/fixed-art-types.h"
 #include "object/tval-types.h"
+#include "system/item-entity.h"
 
 ArtifactType::ArtifactType()
     : bi_key(BaseitemKey(ItemKindType::NONE))
@@ -29,7 +30,84 @@ bool ArtifactType::can_generate(const BaseitemKey &generaing_bi_key) const
     return this->bi_key == generaing_bi_key;
 }
 
-std::map<FixedArtifactId, ArtifactType> artifacts;
+/*!
+ * @brief INSTA_ART型の固定アーティファクト生成を試みる
+ * @param 生成基準階層 (現在フロアそのものではなくボーナスつき)
+ * @param fa_id 固定アーティファクトID
+ * @return 生成に成功したらそのアイテム、失敗したらnullopt
+ */
+std::optional<BaseitemKey> ArtifactType::try_make_instant_artifact(int making_level) const
+{
+    if (!this->can_make_instant_artifact()) {
+        return std::nullopt;
+    }
+
+    if (!this->evaluate_shallow_instant_artifact(making_level)) {
+        return std::nullopt;
+    }
+
+    if (!this->evaluate_rarity()) {
+        return std::nullopt;
+    }
+
+    if (!this->evaluate_shallow_baseitem(making_level)) {
+        return std::nullopt;
+    }
+
+    return this->bi_key;
+}
+
+/*!
+ * @brief INSTA_ARTフラグ付きアーティファクトの生成可否を判定する
+ * @return 生成可否
+ * @details 生成済、クエスト属性付き、非INSTA_ARTはfalse、普通のINSTA_ARTはtrue
+ */
+bool ArtifactType::can_make_instant_artifact() const
+{
+    auto can_make = !this->is_generated;
+    can_make &= this->gen_flags.has_not(ItemGenerationTraitType::QUESTITEM);
+    can_make &= this->gen_flags.has(ItemGenerationTraitType::INSTA_ART);
+    return can_make;
+}
+
+/*!
+ * @brief 標準生成階層より浅い階層での生成制限を判定する
+ * @return 生成可否
+ * @details 1/(不足階層*2) を満たさないと生成しない
+ */
+bool ArtifactType::evaluate_shallow_instant_artifact(int making_level) const
+{
+    if (this->level <= making_level) {
+        return true;
+    }
+
+    return one_in_((this->level - making_level) * 2);
+}
+
+/*!
+ * @brief レアリティによる生成制限を判定する
+ * @return 生成可否
+ */
+bool ArtifactType::evaluate_rarity() const
+{
+    return one_in_(this->rarity);
+}
+
+/*!
+ * @brief 標準生成階層より浅い階層でのベースアイテム生成制限を判定する
+ * @return 生成可否
+ * @details 1/(不足階層*5) を満たさないと生成しない
+ */
+bool ArtifactType::evaluate_shallow_baseitem(int making_level) const
+{
+    const auto &baseitems = BaseitemList::get_instance();
+    const auto &baseitem = baseitems.lookup_baseitem(this->bi_key);
+    if (baseitem.level <= making_level) {
+        return true;
+    }
+
+    return one_in_((baseitem.level - making_level) * 5);
+}
 
 ArtifactList ArtifactList::instance{};
 
@@ -132,3 +210,17 @@ void ArtifactList::reset_generated_flags()
         artifact.is_generated = false;
     }
 }
+
+std::optional<ItemEntity> ArtifactList::try_make_instant_artifact(int making_level) const
+{
+    for (const auto &[fa_id, artifact] : this->artifacts) {
+        const auto bi_key = artifact.try_make_instant_artifact(making_level);
+        if (bi_key) {
+            ItemEntity instant_artifact(*bi_key);
+            instant_artifact.fa_id = fa_id;
+            return instant_artifact;
+        }
+    }
+
+    return std::nullopt;
+}
diff --git a/src/system/artifact-type-definition.h b/src/system/artifact-type-definition.h
index e3e6a223ac..f64a715446 100644
--- a/src/system/artifact-type-definition.h
+++ b/src/system/artifact-type-definition.h
@@ -40,8 +40,16 @@ class ArtifactType {
     RandomArtActType act_idx{}; /*! 発動能力ID / Activative ability index */
 
     bool can_generate(const BaseitemKey &bi_key) const;
+    std::optional<BaseitemKey> try_make_instant_artifact(int making_level) const;
+
+private:
+    bool can_make_instant_artifact() const;
+    bool evaluate_shallow_instant_artifact(int making_level) const;
+    bool evaluate_rarity() const;
+    bool evaluate_shallow_baseitem(int making_level) const;
 };
 
+class ItemEntity;
 class ArtifactList {
 public:
     ArtifactList(const ArtifactList &) = delete;
@@ -65,6 +73,7 @@ class ArtifactList {
     bool order(const FixedArtifactId id1, const FixedArtifactId id2) const;
     void emplace(const FixedArtifactId fa_id, const ArtifactType &artifact);
     void reset_generated_flags();
+    std::optional<ItemEntity> try_make_instant_artifact(int making_level) const;
 
 private:
     ArtifactList() = default;
diff --git a/src/system/floor-type-definition.cpp b/src/system/floor-type-definition.cpp
index 1a0d505200..4dc1fe3aee 100644
--- a/src/system/floor-type-definition.cpp
+++ b/src/system/floor-type-definition.cpp
@@ -1,5 +1,6 @@
 #include "system/floor-type-definition.h"
 #include "dungeon/quest.h"
+#include "floor/geometry.h"
 #include "game-option/birth-options.h"
 #include "monster/monster-timed-effects.h"
 #include "system/angband-system.h"
@@ -125,7 +126,7 @@ QuestId FloorType::get_quest_id(const int bonus) const
  * @param pos 座標
  * @return LOSフラグを持つか否か
  */
-bool FloorType::has_los(const Pos2D pos) const
+bool FloorType::has_los(const Pos2D &pos) const
 {
     return this->get_grid(pos).has_los();
 }
@@ -155,6 +156,58 @@ bool FloorType::can_teleport_level(bool to_player) const
     return this->is_special() || is_invalid_floor;
 }
 
+bool FloorType::is_mark(const Pos2D &pos) const
+{
+    return this->get_grid(pos).is_mark();
+}
+
+bool FloorType::is_closed_door(const Pos2D &pos, bool is_mimic) const
+{
+    const auto &grid = this->get_grid(pos);
+    if (is_mimic) {
+        return grid.get_terrain_mimic().is_closed_door();
+    }
+
+    return grid.get_terrain().is_closed_door();
+}
+
+bool FloorType::is_trap(const Pos2D &pos) const
+{
+    return this->get_grid(pos).get_terrain().is_trap();
+}
+
+/*!
+ * @brief プレイヤーの周辺9マスに該当する地形がいくつあるかを返す
+ * @param p_pos プレイヤーの現在位置
+ * @param gck 判定条件
+ * @param under TRUEならばプレイヤーの直下の座標も走査対象にする
+ * @return 該当する地形の数と、該当する地形の中から1つの座標
+ */
+std::pair<int, Pos2D> FloorType::count_doors_traps(const Pos2D &p_pos, GridCountKind gck, bool under) const
+{
+    auto count = 0;
+    Pos2D pos(0, 0);
+    for (auto d = 0; d < 9; d++) {
+        if ((d == 8) && !under) {
+            continue;
+        }
+
+        Pos2D pos_neighbor = p_pos + Pos2DVec(ddy_ddd[d], ddx_ddd[d]);
+        if (!this->is_mark(pos_neighbor)) {
+            continue;
+        }
+
+        if (!this->check_terrain_state(pos_neighbor, gck)) {
+            continue;
+        }
+
+        ++count;
+        pos = pos_neighbor;
+    }
+
+    return { count, pos };
+}
+
 bool FloorType::check_terrain_state(const Pos2D &pos, GridCountKind gck) const
 {
     const auto &grid = this->get_grid(pos);
@@ -249,69 +302,17 @@ ItemEntity FloorType::make_gold(std::optional<int> initial_offset) const
 
 /*!
  * @brief INSTA_ART型の固定アーティファクトの生成を確率に応じて試行する
- * @param item 生成に割り当てたいアイテムへの参照
- * @return 生成に成功したらTRUEを返す
+ * @return 生成したアイテム (失敗したらnullopt)
+ * @details 地上生成は禁止、生成制限がある場合も禁止、個々のアーティファクト生成条件及び生成確率を潜り抜けなければ生成失敗とする
+ * 最初に潜り抜けたINSTA_ART型の固定アーティファクトを生成し、以後はチェックせずスキップする
  */
 std::optional<ItemEntity> FloorType::try_make_instant_artifact() const
 {
-    /*! @note 地上ではキャンセルする / No artifacts in the town */
-    if (!this->is_in_underground()) {
+    if (!this->is_in_underground() || (get_obj_index_hook != nullptr)) {
         return std::nullopt;
     }
 
-    /*! @note get_obj_index_hookによる指定がある場合は生成をキャンセルする / Themed object */
-    if (get_obj_index_hook) {
-        return std::nullopt;
-    }
-
-    /*! @note 全固定アーティファクト中からIDの若い順に生成対象とその確率を走査する / Check the artifact list (just the "specials") */
-    for (const auto &[fa_id, artifact] : ArtifactList::get_instance()) {
-        /*! @note 既に生成回数がカウントされたアーティファクト、QUESTITEMと非INSTA_ARTは除外 / Cannot make an artifact twice */
-        if (artifact.is_generated) {
-            continue;
-        }
-        if (artifact.gen_flags.has(ItemGenerationTraitType::QUESTITEM)) {
-            continue;
-        }
-        if (!(artifact.gen_flags.has(ItemGenerationTraitType::INSTA_ART))) {
-            continue;
-        }
-
-        /*! @note アーティファクト生成階が現在に対して足りない場合は高確率で1/(不足階層*2)を満たさないと生成リストに加えられない */
-        if (artifact.level > this->object_level) {
-            /* @note  / Acquire the "out-of-depth factor". Roll for out-of-depth creation. */
-            int d = (artifact.level - this->object_level) * 2;
-            if (!one_in_(d)) {
-                continue;
-            }
-        }
-
-        /*! @note 1/(レア度)の確率を満たさないと除外される / Artifact "rarity roll" */
-        if (!one_in_(artifact.rarity)) {
-            continue;
-        }
-
-        /*!
-         * @note INSTA_ART型固定アーティファクトのベースアイテムもチェック対象とする。
-         * ベースアイテムの生成階層が足りない場合1/(不足階層*5)を満たさないと除外される。
-         */
-        const auto &baseitems = BaseitemList::get_instance();
-        const auto &baseitem = baseitems.lookup_baseitem(artifact.bi_key);
-        if (baseitem.level > this->object_level) {
-            int d = (baseitem.level - this->object_level) * 5;
-            if (!one_in_(d)) {
-                continue;
-            }
-        }
-
-        //<! @note 前述の条件を満たしたら、後のIDのアーティファクトはチェックせずすぐ確定し生成処理に移す.
-        ItemEntity instant_artifact(artifact.bi_key);
-        instant_artifact.fa_id = fa_id;
-        return instant_artifact;
-    }
-
-    /*! @note 全INSTA_ART固定アーティファクトを試行しても決まらなかった場合 FALSEを返す / Failure */
-    return std::nullopt;
+    return ArtifactList::get_instance().try_make_instant_artifact(this->object_level);
 }
 
 /*!
diff --git a/src/system/floor-type-definition.h b/src/system/floor-type-definition.h
index 4ec64fc689..b3b844e972 100644
--- a/src/system/floor-type-definition.h
+++ b/src/system/floor-type-definition.h
@@ -6,6 +6,7 @@
 #include <array>
 #include <map>
 #include <optional>
+#include <utility>
 #include <vector>
 
 /*!
@@ -96,9 +97,13 @@ class FloorType {
     dungeon_type &get_dungeon_definition() const;
     QuestId get_random_quest_id(std::optional<int> level_opt = std::nullopt) const;
     QuestId get_quest_id(const int bonus = 0) const;
-    bool has_los(const Pos2D pos) const;
+    bool has_los(const Pos2D &pos) const;
     bool is_special() const;
     bool can_teleport_level(bool to_player = false) const;
+    bool is_mark(const Pos2D &pos) const;
+    bool is_closed_door(const Pos2D &pos, bool is_mimic = false) const;
+    bool is_trap(const Pos2D &pos) const;
+    std::pair<int, Pos2D> count_doors_traps(const Pos2D &p_pos, GridCountKind gck, bool under) const;
     bool check_terrain_state(const Pos2D &pos, GridCountKind gck) const;
     bool order_pet_whistle(short index1, short index2) const;
     bool order_pet_dismission(short index1, short index2, short riding_index) const;
diff --git a/src/target/target-describer.cpp b/src/target/target-describer.cpp
index 7888357900..d33680ae22 100644
--- a/src/target/target-describer.cpp
+++ b/src/target/target-describer.cpp
@@ -238,8 +238,8 @@ static void describe_monster_person(GridExamination *ge_ptr)
 static short describe_monster_item(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
     for (const auto this_o_idx : ge_ptr->m_ptr->hold_o_idx_list) {
-        auto *o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
-        const auto item_name = describe_flavor(player_ptr, *o_ptr, 0);
+        const auto &item = player_ptr->current_floor_ptr->o_list[this_o_idx];
+        const auto item_name = describe_flavor(player_ptr, item, 0);
 #ifdef JP
         const auto out_val = format("%s%s%s%s[%s]", ge_ptr->s1, item_name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
@@ -307,8 +307,8 @@ static short describe_footing(PlayerType *player_ptr, GridExamination *ge_ptr)
         return CONTINUOUS_DESCRIPTION;
     }
 
-    auto *o_ptr = &player_ptr->current_floor_ptr->o_list[ge_ptr->floor_list[0]];
-    const auto item_name = describe_flavor(player_ptr, *o_ptr, 0);
+    const auto &item = player_ptr->current_floor_ptr->o_list[ge_ptr->floor_list[0]];
+    const auto item_name = describe_flavor(player_ptr, item, 0);
 #ifdef JP
     const auto out_val = format("%s%s%s%s[%s]", ge_ptr->s1, item_name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
@@ -393,14 +393,14 @@ static short loop_describing_grid(PlayerType *player_ptr, GridExamination *ge_pt
     }
 }
 
-static short describe_footing_sight(PlayerType *player_ptr, GridExamination *ge_ptr, ItemEntity *o_ptr)
+static short describe_footing_sight(PlayerType *player_ptr, GridExamination *ge_ptr, const ItemEntity &item)
 {
-    if (o_ptr->marked.has_not(OmType::FOUND)) {
+    if (item.marked.has_not(OmType::FOUND)) {
         return CONTINUOUS_DESCRIPTION;
     }
 
     ge_ptr->boring = false;
-    const auto item_name = describe_flavor(player_ptr, *o_ptr, 0);
+    const auto item_name = describe_flavor(player_ptr, item, 0);
 #ifdef JP
     const auto out_val = format("%s%s%s%s[%s]", ge_ptr->s1, item_name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
@@ -417,11 +417,7 @@ static short describe_footing_sight(PlayerType *player_ptr, GridExamination *ge_
         return ge_ptr->query;
     }
 
-    ge_ptr->s1 = _("それは", "It is ");
-    if (o_ptr->number != 1) {
-        ge_ptr->s1 = _("それらは", "They are ");
-    }
-
+    ge_ptr->s1 = item.number == 1 ? _("それは", "It is ") : _("それらは", "They are ");
 #ifdef JP
     ge_ptr->s2 = "の上";
     ge_ptr->s3 = "に見える";
@@ -434,8 +430,8 @@ static short describe_footing_sight(PlayerType *player_ptr, GridExamination *ge_
 static int16_t sweep_footing_items(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
     for (const auto this_o_idx : ge_ptr->g_ptr->o_idx_list) {
-        auto *o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
-        const auto ret = describe_footing_sight(player_ptr, ge_ptr, o_ptr);
+        const auto &item = player_ptr->current_floor_ptr->o_list[this_o_idx];
+        const auto ret = describe_footing_sight(player_ptr, ge_ptr, item);
         if (within_char_util(ret)) {
             return (char)ret;
         }
diff --git a/src/view/display-inventory.cpp b/src/view/display-inventory.cpp
index 8a31386664..77a9a31249 100644
--- a/src/view/display-inventory.cpp
+++ b/src/view/display-inventory.cpp
@@ -30,7 +30,6 @@ COMMAND_CODE show_inventory(PlayerType *player_ptr, int target_item, BIT_FLAGS m
 {
     COMMAND_CODE i;
     int k, l, z = 0;
-    ItemEntity *o_ptr;
     COMMAND_CODE out_index[23]{};
     TERM_COLOR out_color[23]{};
     std::array<std::string, 23> out_desc{};
@@ -41,8 +40,8 @@ COMMAND_CODE show_inventory(PlayerType *player_ptr, int target_item, BIT_FLAGS m
     const auto &[wid, hgt] = term_get_size();
     auto len = wid - col - 1;
     for (i = 0; i < INVEN_PACK; i++) {
-        o_ptr = &player_ptr->inventory_list[i];
-        if (!o_ptr->is_valid()) {
+        const auto &item = player_ptr->inventory_list[i];
+        if (!item.is_valid()) {
             continue;
         }
 
@@ -51,18 +50,18 @@ COMMAND_CODE show_inventory(PlayerType *player_ptr, int target_item, BIT_FLAGS m
 
     prepare_label_string(player_ptr, inven_label, USE_INVEN, item_tester);
     for (k = 0, i = 0; i < z; i++) {
-        o_ptr = &player_ptr->inventory_list[i];
-        if (!item_tester.okay(o_ptr) && !(mode & USE_FULL)) {
+        auto &item = player_ptr->inventory_list[i];
+        if (!item_tester.okay(&item) && !(mode & USE_FULL)) {
             continue;
         }
 
         out_index[k] = i;
-        out_color[k] = tval_to_attr[enum2i(o_ptr->bi_key.tval()) % 128];
-        if (o_ptr->timeout) {
+        out_color[k] = tval_to_attr[enum2i(item.bi_key.tval()) % 128];
+        if (item.timeout) {
             out_color[k] = TERM_L_DARK;
         }
 
-        out_desc[k] = describe_flavor(player_ptr, *o_ptr, 0);
+        out_desc[k] = describe_flavor(player_ptr, item, 0);
         l = out_desc[k].length() + 5;
         if (show_weights) {
             l += 9;
@@ -87,7 +86,7 @@ COMMAND_CODE show_inventory(PlayerType *player_ptr, int target_item, BIT_FLAGS m
     int j;
     for (j = 0; j < k; j++) {
         i = out_index[j];
-        o_ptr = &player_ptr->inventory_list[i];
+        const auto &item = player_ptr->inventory_list[i];
         prt("", j + 1, col ? col - 2 : col);
         std::string head;
         if (use_menu && target_item) {
@@ -106,7 +105,7 @@ COMMAND_CODE show_inventory(PlayerType *player_ptr, int target_item, BIT_FLAGS m
         put_str(head, j + 1, col);
         cur_col = col + 3;
         if (show_item_graph) {
-            term_queue_bigchar(cur_col, j + 1, { o_ptr->get_symbol(), {} });
+            term_queue_bigchar(cur_col, j + 1, { item.get_symbol(), {} });
             if (use_bigtile) {
                 cur_col++;
             }
@@ -116,7 +115,7 @@ COMMAND_CODE show_inventory(PlayerType *player_ptr, int target_item, BIT_FLAGS m
 
         c_put_str(out_color[j], out_desc[j], j + 1, cur_col);
         if (show_weights) {
-            int wgt = o_ptr->weight * o_ptr->number;
+            const auto wgt = item.weight * item.number;
             const auto weight = format(_("%3d.%1d kg", "%3d.%1d lb"), _(lb_to_kg_integer(wgt), wgt / 10), _(lb_to_kg_fraction(wgt), wgt % 10));
             prt(weight, j + 1, wid - 9);
         }
@@ -156,8 +155,8 @@ void display_inventory(PlayerType *player_ptr, const ItemTester &item_tester)
             break;
         }
 
-        auto o_ptr = &player_ptr->inventory_list[i];
-        auto do_disp = item_tester.okay(o_ptr);
+        auto &item = player_ptr->inventory_list[i];
+        auto do_disp = item_tester.okay(&item);
         std::string label = "   ";
         if (do_disp) {
             label[0] = index_to_label(i);
@@ -167,14 +166,14 @@ void display_inventory(PlayerType *player_ptr, const ItemTester &item_tester)
         int cur_col = 3;
         term_erase(cur_col, i);
         term_putstr(0, i, cur_col, TERM_WHITE, label);
-        const auto item_name = describe_flavor(player_ptr, *o_ptr, 0);
-        attr = tval_to_attr[enum2i(o_ptr->bi_key.tval()) % 128];
-        if (o_ptr->timeout) {
+        const auto item_name = describe_flavor(player_ptr, item, 0);
+        attr = tval_to_attr[enum2i(item.bi_key.tval()) % 128];
+        if (item.timeout) {
             attr = TERM_L_DARK;
         }
 
         if (show_item_graph) {
-            term_queue_bigchar(cur_col, i, { o_ptr->get_symbol(), {} });
+            term_queue_bigchar(cur_col, i, { item.get_symbol(), {} });
             if (use_bigtile) {
                 cur_col++;
             }
@@ -185,7 +184,7 @@ void display_inventory(PlayerType *player_ptr, const ItemTester &item_tester)
         term_putstr(cur_col, i, item_name.length(), attr, item_name);
 
         if (show_weights) {
-            int wgt = o_ptr->weight * o_ptr->number;
+            const auto wgt = item.weight * item.number;
             const auto weight = format(_("%3d.%1d kg", "%3d.%1d lb"),
                 _(lb_to_kg_integer(wgt), wgt / 10),
                 _(lb_to_kg_fraction(wgt), wgt % 10));
diff --git a/src/view/object-describer.cpp b/src/view/object-describer.cpp
index 260dd9ae94..3aa3b9383f 100644
--- a/src/view/object-describer.cpp
+++ b/src/view/object-describer.cpp
@@ -47,10 +47,10 @@ void inven_item_charges(const ItemEntity &item)
  */
 void inven_item_describe(PlayerType *player_ptr, short i_idx)
 {
-    auto *o_ptr = &player_ptr->inventory_list[i_idx];
-    const auto item_name = describe_flavor(player_ptr, *o_ptr, 0);
+    const auto &item = player_ptr->inventory_list[i_idx];
+    const auto item_name = describe_flavor(player_ptr, item, 0);
 #ifdef JP
-    if (o_ptr->number <= 0) {
+    if (item.number <= 0) {
         msg_format("もう%sを持っていない。", item_name.data());
     } else {
         msg_format("まだ %sを持っている。", item_name.data());