OSDN Git Service

[Refactor] Grid::has_monster()の定義
[hengbandforosx/hengbandosx.git] / src / target / target-describer.cpp
index 0f60941..61323a4 100644 (file)
@@ -1,4 +1,4 @@
-#include "target/target-describer.h"
+#include "target/target-describer.h"
 #include "action/travel-execution.h"
 #include "core/stuff-handler.h"
 #include "dungeon/quest.h"
@@ -17,7 +17,6 @@
 #include "locale/english.h"
 #include "lore/lore-util.h"
 #include "monster-race/monster-race.h"
-#include "monster-race/race-flags1.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-description-types.h"
 #include "monster/monster-flag-types.h"
 #include "window/display-sub-windows.h"
 #include "world/world.h"
 
-static const int16_t CONTINUOUS_DESCRIPTION = 256;
+namespace {
+constexpr short CONTINUOUS_DESCRIPTION = 256;
 
-bool show_gold_on_floor = false;
-
-// Examine grid
-struct eg_type {
+class GridExamination {
+public:
+    GridExamination(FloorType &floor, POSITION y, POSITION x, target_type mode, concptr info);
     POSITION y;
     POSITION x;
     target_type mode;
-    bool boring;
+    bool boring = true;
     concptr info;
-    concptr s1;
-    concptr s2;
-    concptr s3;
-    concptr x_info;
-    char query;
-    char out_val[MAX_NLEN + 80];
-    OBJECT_IDX floor_list[23];
-    ITEM_NUMBER floor_num;
-    grid_type *g_ptr;
+    concptr s1 = "";
+    concptr s2 = "";
+    concptr s3 = "";
+    concptr x_info = "";
+    char query = '\001';
+    char out_val[MAX_NLEN + 80]{};
+    OBJECT_IDX floor_list[23]{};
+    ITEM_NUMBER floor_num = 0;
+    Grid *g_ptr;
     MonsterEntity *m_ptr;
-    OBJECT_IDX next_o_idx;
-    FEAT_IDX feat;
-    TerrainType *f_ptr;
-    concptr name;
+    OBJECT_IDX next_o_idx = 0;
+    FEAT_IDX feat = 0;
+    TerrainType *terrain_ptr = nullptr;
+    std::string name = "";
 };
 
-static eg_type *initialize_eg_type(PlayerType *player_ptr, eg_type *eg_ptr, POSITION y, POSITION x, target_type mode, concptr info)
+GridExamination::GridExamination(FloorType &floor, POSITION y, POSITION x, target_type mode, concptr info)
+    : y(y)
+    , x(x)
+    , mode(mode)
+    , info(info)
 {
-    eg_ptr->y = y;
-    eg_ptr->x = x;
-    eg_ptr->boring = true;
-    eg_ptr->mode = mode;
-    eg_ptr->info = info;
-    eg_ptr->s1 = "";
-    eg_ptr->s2 = "";
-    eg_ptr->s3 = "";
-    eg_ptr->x_info = "";
-    eg_ptr->query = '\001';
-    eg_ptr->floor_num = 0;
-
-    auto *floor_ptr = player_ptr->current_floor_ptr;
-    eg_ptr->g_ptr = &floor_ptr->grid_array[y][x];
-    eg_ptr->m_ptr = &floor_ptr->m_list[eg_ptr->g_ptr->m_idx];
-    eg_ptr->next_o_idx = 0;
-    return eg_ptr;
+    this->g_ptr = &floor.grid_array[y][x];
+    this->m_ptr = &floor.m_list[this->g_ptr->m_idx];
+    this->next_o_idx = 0;
+}
 }
 
+bool show_gold_on_floor = false;
+
 /*
  * Evaluate number of kill needed to gain level
  */
 static std::string evaluate_monster_exp(PlayerType *player_ptr, MonsterEntity *m_ptr)
 {
-    MonsterRaceInfo *ap_r_ptr = &monraces_info[m_ptr->ap_r_idx];
+    MonsterRaceInfo *ap_r_ptr = &m_ptr->get_appearance_monrace();
     if ((player_ptr->lev >= PY_MAX_LEVEL) || PlayerRace(player_ptr).equals(PlayerRaceType::ANDROID)) {
         return "**";
     }
@@ -131,36 +123,36 @@ static std::string evaluate_monster_exp(PlayerType *player_ptr, MonsterEntity *m
     return format("%03ld", (long int)num);
 }
 
-static void describe_scan_result(PlayerType *player_ptr, eg_type *eg_ptr)
+static void describe_scan_result(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
     if (!easy_floor) {
         return;
     }
 
-    eg_ptr->floor_num = scan_floor_items(player_ptr, eg_ptr->floor_list, eg_ptr->y, eg_ptr->x, SCAN_FLOOR_ONLY_MARKED, AllMatchItemTester());
-    if (eg_ptr->floor_num > 0) {
-        eg_ptr->x_info = _("x物 ", "x,");
+    ge_ptr->floor_num = scan_floor_items(player_ptr, ge_ptr->floor_list, ge_ptr->y, ge_ptr->x, SCAN_FLOOR_ONLY_MARKED, AllMatchItemTester());
+    if (ge_ptr->floor_num > 0) {
+        ge_ptr->x_info = _("x物 ", "x,");
     }
 }
 
-static void describe_target(PlayerType *player_ptr, eg_type *eg_ptr)
+static void describe_target(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
-    if (!player_bold(player_ptr, eg_ptr->y, eg_ptr->x)) {
-        eg_ptr->s1 = _("ターゲット:", "Target:");
+    if (!player_ptr->is_located_at({ ge_ptr->y, ge_ptr->x })) {
+        ge_ptr->s1 = _("ターゲット:", "Target:");
         return;
     }
 
 #ifdef JP
-    eg_ptr->s1 = "あなたは";
-    eg_ptr->s2 = "の上";
-    eg_ptr->s3 = "にいる";
+    ge_ptr->s1 = "あなたは";
+    ge_ptr->s2 = "の上";
+    ge_ptr->s3 = "にいる";
 #else
-    eg_ptr->s1 = "You are ";
-    eg_ptr->s2 = "on ";
+    ge_ptr->s1 = "You are ";
+    ge_ptr->s2 = "on ";
 #endif
 }
 
-static ProcessResult describe_hallucinated_target(PlayerType *player_ptr, eg_type *eg_ptr)
+static ProcessResult describe_hallucinated_target(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
     if (!player_ptr->effects()->hallucination()->is_hallucinated()) {
         return ProcessResult::PROCESS_CONTINUE;
@@ -168,38 +160,37 @@ static ProcessResult describe_hallucinated_target(PlayerType *player_ptr, eg_typ
 
     concptr name = _("何か奇妙な物", "something strange");
 #ifdef JP
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s [%s]", eg_ptr->s1, name, eg_ptr->s2, eg_ptr->s3, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s [%s]", ge_ptr->s1, name, ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s [%s]", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, name, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s [%s]", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, name, ge_ptr->info);
 #endif
-    prt(eg_ptr->out_val, 0, 0);
-    move_cursor_relative(eg_ptr->y, eg_ptr->x);
-    eg_ptr->query = inkey();
-    if ((eg_ptr->query != '\r') && (eg_ptr->query != '\n')) {
+    prt(ge_ptr->out_val, 0, 0);
+    move_cursor_relative(ge_ptr->y, ge_ptr->x);
+    ge_ptr->query = inkey();
+    if ((ge_ptr->query != '\r') && (ge_ptr->query != '\n')) {
         return ProcessResult::PROCESS_TRUE;
     }
 
     return ProcessResult::PROCESS_FALSE;
 }
 
-static bool describe_grid_lore(PlayerType *player_ptr, eg_type *eg_ptr)
+static bool describe_grid_lore(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
     screen_save();
-    screen_roff(player_ptr, eg_ptr->m_ptr->ap_r_idx, MONSTER_LORE_NORMAL);
-    term_addstr(-1, TERM_WHITE, format(_("  [r思 %s%s]", "  [r,%s%s]"), eg_ptr->x_info, eg_ptr->info));
-    eg_ptr->query = inkey();
+    screen_roff(player_ptr, ge_ptr->m_ptr->ap_r_idx, MONSTER_LORE_NORMAL);
+    term_addstr(-1, TERM_WHITE, format(_("  [r思 %s%s]", "  [r,%s%s]"), ge_ptr->x_info, ge_ptr->info));
+    ge_ptr->query = inkey();
     screen_load();
-    return eg_ptr->query != 'r';
+    return ge_ptr->query != 'r';
 }
 
-static void describe_grid_monster(PlayerType *player_ptr, eg_type *eg_ptr)
+static void describe_grid_monster(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
     bool recall = false;
-    GAME_TEXT m_name[MAX_NLEN];
-    monster_desc(player_ptr, m_name, eg_ptr->m_ptr, MD_INDEF_VISIBLE);
+    const auto m_name = monster_desc(player_ptr, ge_ptr->m_ptr, MD_INDEF_VISIBLE);
     while (true) {
         if (recall) {
-            if (describe_grid_lore(player_ptr, eg_ptr)) {
+            if (describe_grid_lore(player_ptr, ge_ptr)) {
                 return;
             }
 
@@ -207,18 +198,19 @@ static void describe_grid_monster(PlayerType *player_ptr, eg_type *eg_ptr)
             continue;
         }
 
-        std::string acount = evaluate_monster_exp(player_ptr, eg_ptr->m_ptr);
+        std::string acount = evaluate_monster_exp(player_ptr, ge_ptr->m_ptr);
+        const auto mon_desc = look_mon_desc(ge_ptr->m_ptr, 0x01);
 #ifdef JP
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "[%s]%s%s(%s)%s%s [r思 %s%s]", acount.data(), eg_ptr->s1, m_name, look_mon_desc(eg_ptr->m_ptr, 0x01), eg_ptr->s2, eg_ptr->s3,
-            eg_ptr->x_info, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "[%s]%s%s(%s)%s%s [r思 %s%s]", acount.data(), ge_ptr->s1, m_name.data(), mon_desc.data(), ge_ptr->s2, ge_ptr->s3,
+            ge_ptr->x_info, ge_ptr->info);
 #else
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "[%s]%s%s%s%s(%s) [r, %s%s]", acount.data(), eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, m_name, look_mon_desc(eg_ptr->m_ptr, 0x01),
-            eg_ptr->x_info, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "[%s]%s%s%s%s(%s) [r, %s%s]", acount.data(), ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, m_name.data(), mon_desc.data(),
+            ge_ptr->x_info, ge_ptr->info);
 #endif
-        prt(eg_ptr->out_val, 0, 0);
-        move_cursor_relative(eg_ptr->y, eg_ptr->x);
-        eg_ptr->query = inkey();
-        if (eg_ptr->query != 'r') {
+        prt(ge_ptr->out_val, 0, 0);
+        move_cursor_relative(ge_ptr->y, ge_ptr->x);
+        ge_ptr->query = inkey();
+        if (ge_ptr->query != 'r') {
             return;
         }
 
@@ -226,231 +218,225 @@ static void describe_grid_monster(PlayerType *player_ptr, eg_type *eg_ptr)
     }
 }
 
-static void describe_monster_person(eg_type *eg_ptr)
+static void describe_monster_person(GridExamination *ge_ptr)
 {
-    MonsterRaceInfo *ap_r_ptr = &monraces_info[eg_ptr->m_ptr->ap_r_idx];
-    eg_ptr->s1 = _("それは", "It is ");
-    if (ap_r_ptr->flags1 & RF1_FEMALE) {
-        eg_ptr->s1 = _("彼女は", "She is ");
-    } else if (ap_r_ptr->flags1 & RF1_MALE) {
-        eg_ptr->s1 = _("彼は", "He is ");
+    const auto &monrace = ge_ptr->m_ptr->get_appearance_monrace();
+    ge_ptr->s1 = _("それは", "It is ");
+    if (monrace.sex == MonsterSex::FEMALE) {
+        ge_ptr->s1 = _("彼女は", "She is ");
+    } else if (monrace.sex == MonsterSex::MALE) {
+        ge_ptr->s1 = _("彼は", "He is ");
     }
 
 #ifdef JP
-    eg_ptr->s2 = "を";
-    eg_ptr->s3 = "持っている";
+    ge_ptr->s2 = "を";
+    ge_ptr->s3 = "持っている";
 #else
-    eg_ptr->s2 = "carrying ";
+    ge_ptr->s2 = "carrying ";
 #endif
 }
 
-static uint16_t describe_monster_item(PlayerType *player_ptr, eg_type *eg_ptr)
+static short describe_monster_item(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
-    for (const auto this_o_idx : eg_ptr->m_ptr->hold_o_idx_list) {
-        GAME_TEXT o_name[MAX_NLEN];
-        ItemEntity *o_ptr;
-        o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
-        describe_flavor(player_ptr, o_name, o_ptr, 0);
+    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);
 #ifdef JP
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s[%s]", eg_ptr->s1, o_name, eg_ptr->s2, eg_ptr->s3, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s[%s]", ge_ptr->s1, item_name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s [%s]", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, o_name, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s [%s]", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, item_name.data(), ge_ptr->info);
 #endif
-        prt(eg_ptr->out_val, 0, 0);
-        move_cursor_relative(eg_ptr->y, eg_ptr->x);
-        eg_ptr->query = inkey();
-        if ((eg_ptr->query != '\r') && (eg_ptr->query != '\n') && (eg_ptr->query != ' ') && (eg_ptr->query != 'x')) {
-            return eg_ptr->query;
+        prt(ge_ptr->out_val, 0, 0);
+        move_cursor_relative(ge_ptr->y, ge_ptr->x);
+        ge_ptr->query = inkey();
+        if ((ge_ptr->query != '\r') && (ge_ptr->query != '\n') && (ge_ptr->query != ' ') && (ge_ptr->query != 'x')) {
+            return ge_ptr->query;
         }
 
-        if ((eg_ptr->query == ' ') && !(eg_ptr->mode & TARGET_LOOK)) {
-            return eg_ptr->query;
+        if ((ge_ptr->query == ' ') && !(ge_ptr->mode & TARGET_LOOK)) {
+            return ge_ptr->query;
         }
 
-        eg_ptr->s2 = _("をまた", "also carrying ");
+        ge_ptr->s2 = _("をまた", "also carrying ");
     }
 
     return CONTINUOUS_DESCRIPTION;
 }
 
-static bool within_char_util(int16_t input)
+static bool within_char_util(const short input)
 {
     return (input > -127) && (input < 128);
 }
 
-static int16_t describe_grid(PlayerType *player_ptr, eg_type *eg_ptr)
+static short describe_grid(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
-    if ((eg_ptr->g_ptr->m_idx == 0) || !player_ptr->current_floor_ptr->m_list[eg_ptr->g_ptr->m_idx].ml) {
+    if (!ge_ptr->g_ptr->has_monster() || !player_ptr->current_floor_ptr->m_list[ge_ptr->g_ptr->m_idx].ml) {
         return CONTINUOUS_DESCRIPTION;
     }
 
-    eg_ptr->boring = false;
-    monster_race_track(player_ptr, eg_ptr->m_ptr->ap_r_idx);
-    health_track(player_ptr, eg_ptr->g_ptr->m_idx);
+    ge_ptr->boring = false;
+    monster_race_track(player_ptr, ge_ptr->m_ptr->ap_r_idx);
+    health_track(player_ptr, ge_ptr->g_ptr->m_idx);
     handle_stuff(player_ptr);
-    describe_grid_monster(player_ptr, eg_ptr);
-    if ((eg_ptr->query != '\r') && (eg_ptr->query != '\n') && (eg_ptr->query != ' ') && (eg_ptr->query != 'x')) {
-        return eg_ptr->query;
+    describe_grid_monster(player_ptr, ge_ptr);
+    if ((ge_ptr->query != '\r') && (ge_ptr->query != '\n') && (ge_ptr->query != ' ') && (ge_ptr->query != 'x')) {
+        return ge_ptr->query;
     }
 
-    if ((eg_ptr->query == ' ') && !(eg_ptr->mode & TARGET_LOOK)) {
-        return eg_ptr->query;
+    if ((ge_ptr->query == ' ') && !(ge_ptr->mode & TARGET_LOOK)) {
+        return ge_ptr->query;
     }
 
-    describe_monster_person(eg_ptr);
-    uint16_t monster_item_description = describe_monster_item(player_ptr, eg_ptr);
+    describe_monster_person(ge_ptr);
+    const auto monster_item_description = describe_monster_item(player_ptr, ge_ptr);
     if (within_char_util(monster_item_description)) {
         return (char)monster_item_description;
     }
 
 #ifdef JP
-    eg_ptr->s2 = "の上";
-    eg_ptr->s3 = "にいる";
+    ge_ptr->s2 = "の上";
+    ge_ptr->s3 = "にいる";
 #else
-    eg_ptr->s2 = "on ";
+    ge_ptr->s2 = "on ";
 #endif
     return CONTINUOUS_DESCRIPTION;
 }
 
-static int16_t describe_footing(PlayerType *player_ptr, eg_type *eg_ptr)
+static short describe_footing(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
-    if (eg_ptr->floor_num != 1) {
+    if (ge_ptr->floor_num != 1) {
         return CONTINUOUS_DESCRIPTION;
     }
 
-    GAME_TEXT o_name[MAX_NLEN];
-    ItemEntity *o_ptr;
-    o_ptr = &player_ptr->current_floor_ptr->o_list[eg_ptr->floor_list[0]];
-    describe_flavor(player_ptr, o_name, o_ptr, 0);
+    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);
 #ifdef JP
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s[%s]", eg_ptr->s1, o_name, eg_ptr->s2, eg_ptr->s3, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s[%s]", ge_ptr->s1, item_name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s [%s]", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, o_name, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s [%s]", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, item_name.data(), ge_ptr->info);
 #endif
-    prt(eg_ptr->out_val, 0, 0);
-    move_cursor_relative(eg_ptr->y, eg_ptr->x);
-    eg_ptr->query = inkey();
-    return eg_ptr->query;
+    prt(ge_ptr->out_val, 0, 0);
+    move_cursor_relative(ge_ptr->y, ge_ptr->x);
+    ge_ptr->query = inkey();
+    return ge_ptr->query;
 }
 
-static int16_t describe_footing_items(eg_type *eg_ptr)
+static short describe_footing_items(GridExamination *ge_ptr)
 {
-    if (!eg_ptr->boring) {
+    if (!ge_ptr->boring) {
         return CONTINUOUS_DESCRIPTION;
     }
 
 #ifdef JP
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s %d個のアイテム%s%s ['x'で一覧, %s]", eg_ptr->s1, (int)eg_ptr->floor_num, eg_ptr->s2, eg_ptr->s3, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s %d個のアイテム%s%s ['x'で一覧, %s]", ge_ptr->s1, (int)ge_ptr->floor_num, ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%sa pile of %d items [x,%s]", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, (int)eg_ptr->floor_num, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%sa pile of %d items [x,%s]", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, (int)ge_ptr->floor_num, ge_ptr->info);
 #endif
-    prt(eg_ptr->out_val, 0, 0);
-    move_cursor_relative(eg_ptr->y, eg_ptr->x);
-    eg_ptr->query = inkey();
-    if (eg_ptr->query != 'x' && eg_ptr->query != ' ') {
-        return eg_ptr->query;
+    prt(ge_ptr->out_val, 0, 0);
+    move_cursor_relative(ge_ptr->y, ge_ptr->x);
+    ge_ptr->query = inkey();
+    if (ge_ptr->query != 'x' && ge_ptr->query != ' ') {
+        return ge_ptr->query;
     }
 
     return CONTINUOUS_DESCRIPTION;
 }
 
-static char describe_footing_many_items(PlayerType *player_ptr, eg_type *eg_ptr, int *min_width)
+static char describe_footing_many_items(PlayerType *player_ptr, GridExamination *ge_ptr, int *min_width)
 {
     while (true) {
         screen_save();
         show_gold_on_floor = true;
-        (void)show_floor_items(player_ptr, 0, eg_ptr->y, eg_ptr->x, min_width, AllMatchItemTester());
+        (void)show_floor_items(player_ptr, 0, ge_ptr->y, ge_ptr->x, min_width, AllMatchItemTester());
         show_gold_on_floor = false;
 #ifdef JP
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s %d個のアイテム%s%s [Enterで次へ, %s]", eg_ptr->s1, (int)eg_ptr->floor_num, eg_ptr->s2, eg_ptr->s3, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s %d個のアイテム%s%s [Enterで次へ, %s]", ge_ptr->s1, (int)ge_ptr->floor_num, ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%sa pile of %d items [Enter,%s]", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, (int)eg_ptr->floor_num, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%sa pile of %d items [Enter,%s]", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, (int)ge_ptr->floor_num, ge_ptr->info);
 #endif
-        prt(eg_ptr->out_val, 0, 0);
-        eg_ptr->query = inkey();
+        prt(ge_ptr->out_val, 0, 0);
+        ge_ptr->query = inkey();
         screen_load();
-        if (eg_ptr->query != '\n' && eg_ptr->query != '\r') {
-            return eg_ptr->query;
+        if (ge_ptr->query != '\n' && ge_ptr->query != '\r') {
+            return ge_ptr->query;
         }
 
-        if (eg_ptr->g_ptr->o_idx_list.size() < 2) {
+        if (ge_ptr->g_ptr->o_idx_list.size() < 2) {
             continue;
         }
 
-        eg_ptr->g_ptr->o_idx_list.rotate(player_ptr->current_floor_ptr);
+        ge_ptr->g_ptr->o_idx_list.rotate(player_ptr->current_floor_ptr);
 
         // ターゲットしている床の座標を渡す必要があるので、window_stuff経由ではなく直接呼び出す
-        fix_floor_item_list(player_ptr, eg_ptr->y, eg_ptr->x);
+        fix_floor_item_list(player_ptr, { ge_ptr->y, ge_ptr->x });
     }
 }
 
-static int16_t loop_describing_grid(PlayerType *player_ptr, eg_type *eg_ptr)
+static short loop_describing_grid(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
-    if (eg_ptr->floor_num == 0) {
+    if (ge_ptr->floor_num == 0) {
         return CONTINUOUS_DESCRIPTION;
     }
 
-    int min_width = 0;
+    auto min_width = 0;
     while (true) {
-        int16_t footing_description = describe_footing(player_ptr, eg_ptr);
+        const auto footing_description = describe_footing(player_ptr, ge_ptr);
         if (within_char_util(footing_description)) {
             return (char)footing_description;
         }
 
-        int16_t footing_descriptions = describe_footing_items(eg_ptr);
+        const auto footing_descriptions = describe_footing_items(ge_ptr);
         if (within_char_util(footing_descriptions)) {
             return (char)footing_descriptions;
         }
 
-        return describe_footing_many_items(player_ptr, eg_ptr, &min_width);
+        return describe_footing_many_items(player_ptr, ge_ptr, &min_width);
     }
 }
 
-static int16_t describe_footing_sight(PlayerType *player_ptr, eg_type *eg_ptr, ItemEntity *o_ptr)
+static short describe_footing_sight(PlayerType *player_ptr, GridExamination *ge_ptr, ItemEntity *o_ptr)
 {
     if (o_ptr->marked.has_not(OmType::FOUND)) {
         return CONTINUOUS_DESCRIPTION;
     }
 
-    GAME_TEXT o_name[MAX_NLEN];
-    eg_ptr->boring = false;
-    describe_flavor(player_ptr, o_name, o_ptr, 0);
+    ge_ptr->boring = false;
+    const auto item_name = describe_flavor(player_ptr, o_ptr, 0);
 #ifdef JP
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s[%s]", eg_ptr->s1, o_name, eg_ptr->s2, eg_ptr->s3, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s[%s]", ge_ptr->s1, item_name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s [%s]", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, o_name, eg_ptr->info);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s [%s]", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, item_name.data(), ge_ptr->info);
 #endif
-    prt(eg_ptr->out_val, 0, 0);
-    move_cursor_relative(eg_ptr->y, eg_ptr->x);
-    eg_ptr->query = inkey();
-    if ((eg_ptr->query != '\r') && (eg_ptr->query != '\n') && (eg_ptr->query != ' ') && (eg_ptr->query != 'x')) {
-        return eg_ptr->query;
+    prt(ge_ptr->out_val, 0, 0);
+    move_cursor_relative(ge_ptr->y, ge_ptr->x);
+    ge_ptr->query = inkey();
+    if ((ge_ptr->query != '\r') && (ge_ptr->query != '\n') && (ge_ptr->query != ' ') && (ge_ptr->query != 'x')) {
+        return ge_ptr->query;
     }
 
-    if ((eg_ptr->query == ' ') && !(eg_ptr->mode & TARGET_LOOK)) {
-        return eg_ptr->query;
+    if ((ge_ptr->query == ' ') && !(ge_ptr->mode & TARGET_LOOK)) {
+        return ge_ptr->query;
     }
 
-    eg_ptr->s1 = _("それは", "It is ");
+    ge_ptr->s1 = _("それは", "It is ");
     if (o_ptr->number != 1) {
-        eg_ptr->s1 = _("それらは", "They are ");
+        ge_ptr->s1 = _("それらは", "They are ");
     }
 
 #ifdef JP
-    eg_ptr->s2 = "の上";
-    eg_ptr->s3 = "に見える";
+    ge_ptr->s2 = "の上";
+    ge_ptr->s3 = "に見える";
 #else
-    eg_ptr->s2 = "on ";
+    ge_ptr->s2 = "on ";
 #endif
     return CONTINUOUS_DESCRIPTION;
 }
 
-static int16_t sweep_footing_items(PlayerType *player_ptr, eg_type *eg_ptr)
+static int16_t sweep_footing_items(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
-    for (const auto this_o_idx : eg_ptr->g_ptr->o_idx_list) {
-        ItemEntity *o_ptr;
-        o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
-        int16_t ret = describe_footing_sight(player_ptr, eg_ptr, o_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);
         if (within_char_util(ret)) {
             return (char)ret;
         }
@@ -459,12 +445,13 @@ static int16_t sweep_footing_items(PlayerType *player_ptr, eg_type *eg_ptr)
     return CONTINUOUS_DESCRIPTION;
 }
 
-static concptr decide_target_floor(PlayerType *player_ptr, eg_type *eg_ptr)
+static std::string decide_target_floor(PlayerType *player_ptr, GridExamination *ge_ptr)
 {
-    if (eg_ptr->f_ptr->flags.has(TerrainCharacteristics::QUEST_ENTER)) {
-        QuestId old_quest = player_ptr->current_floor_ptr->quest_number;
+    auto *floor_ptr = player_ptr->current_floor_ptr;
+    if (ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::QUEST_ENTER)) {
+        QuestId old_quest = floor_ptr->quest_number;
         const auto &quest_list = QuestList::get_instance();
-        const QuestId number = i2enum<QuestId>(eg_ptr->g_ptr->special);
+        const QuestId number = i2enum<QuestId>(ge_ptr->g_ptr->special);
         const auto *q_ptr = &quest_list[number];
         std::string_view msg(_("クエスト「%s」(%d階相当)", "the entrance to the quest '%s'(level %d)"));
         for (int j = 0; j < 10; j++) {
@@ -472,57 +459,58 @@ static concptr decide_target_floor(PlayerType *player_ptr, eg_type *eg_ptr)
         }
 
         quest_text_line = 0;
-        player_ptr->current_floor_ptr->quest_number = number;
+        floor_ptr->quest_number = number;
         init_flags = INIT_NAME_ONLY;
         parse_fixed_map(player_ptr, QUEST_DEFINITION_LIST, 0, 0, 0, 0);
-        player_ptr->current_floor_ptr->quest_number = old_quest;
-        return format(msg.data(), q_ptr->name, q_ptr->level);
+        floor_ptr->quest_number = old_quest;
+        return format(msg.data(), q_ptr->name.data(), q_ptr->level);
     }
 
-    if (eg_ptr->f_ptr->flags.has(TerrainCharacteristics::BLDG) && !player_ptr->current_floor_ptr->inside_arena) {
-        return building[eg_ptr->f_ptr->subtype].name;
+    if (ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::BLDG) && !floor_ptr->inside_arena) {
+        return buildings[ge_ptr->terrain_ptr->subtype].name;
     }
 
-    if (eg_ptr->f_ptr->flags.has(TerrainCharacteristics::ENTRANCE)) {
-        return format(_("%s(%d階相当)", "%s(level %d)"), dungeons_info[eg_ptr->g_ptr->special].text.data(), dungeons_info[eg_ptr->g_ptr->special].mindepth);
+    if (ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::ENTRANCE)) {
+        const auto &dungeon = dungeons_info[ge_ptr->g_ptr->special];
+        return format(_("%s(%d階相当)", "%s(level %d)"), dungeon.text.data(), dungeon.mindepth);
     }
 
-    if (eg_ptr->f_ptr->flags.has(TerrainCharacteristics::TOWN)) {
-        return town_info[eg_ptr->g_ptr->special].name;
+    if (ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::TOWN)) {
+        return towns_info[ge_ptr->g_ptr->special].name;
     }
 
-    if (player_ptr->wild_mode && (eg_ptr->feat == feat_floor)) {
+    if (player_ptr->wild_mode && (ge_ptr->feat == feat_floor)) {
         return _("道", "road");
     }
 
-    return eg_ptr->f_ptr->name.data();
+    return ge_ptr->terrain_ptr->name;
 }
 
-static void describe_grid_monster_all(eg_type *eg_ptr)
+static void describe_grid_monster_all(GridExamination *ge_ptr)
 {
     if (!w_ptr->wizard) {
 #ifdef JP
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s[%s]", eg_ptr->s1, eg_ptr->name, eg_ptr->s2, eg_ptr->s3, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s[%s]", ge_ptr->s1, ge_ptr->name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info);
 #else
-        strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s [%s]", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, eg_ptr->name, eg_ptr->info);
+        strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s [%s]", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, ge_ptr->name.data(), ge_ptr->info);
 #endif
         return;
     }
 
     std::string f_idx_str;
-    if (eg_ptr->g_ptr->mimic) {
-        f_idx_str = format("%d/%d", eg_ptr->g_ptr->feat, eg_ptr->g_ptr->mimic);
+    if (ge_ptr->g_ptr->mimic) {
+        f_idx_str = format("%d/%d", ge_ptr->g_ptr->feat, ge_ptr->g_ptr->mimic);
     } else {
-        f_idx_str = std::to_string(eg_ptr->g_ptr->feat);
+        f_idx_str = std::to_string(ge_ptr->g_ptr->feat);
     }
 
 #ifdef JP
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s[%s] %x %s %d %d %d (%d,%d) %d", eg_ptr->s1, eg_ptr->name, eg_ptr->s2, eg_ptr->s3, eg_ptr->info,
-        (uint)eg_ptr->g_ptr->info, f_idx_str.data(), eg_ptr->g_ptr->dists[FLOW_NORMAL], eg_ptr->g_ptr->costs[FLOW_NORMAL], eg_ptr->g_ptr->when, (int)eg_ptr->y,
-        (int)eg_ptr->x, travel.cost[eg_ptr->y][eg_ptr->x]);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s[%s] %x %s %d %d %d (%d,%d) %d", ge_ptr->s1, ge_ptr->name.data(), ge_ptr->s2, ge_ptr->s3, ge_ptr->info,
+        (uint)ge_ptr->g_ptr->info, f_idx_str.data(), ge_ptr->g_ptr->dists[FLOW_NORMAL], ge_ptr->g_ptr->costs[FLOW_NORMAL], ge_ptr->g_ptr->when, (int)ge_ptr->y,
+        (int)ge_ptr->x, travel.cost[ge_ptr->y][ge_ptr->x]);
 #else
-    strnfmt(eg_ptr->out_val, sizeof(eg_ptr->out_val), "%s%s%s%s [%s] %x %s %d %d %d (%d,%d)", eg_ptr->s1, eg_ptr->s2, eg_ptr->s3, eg_ptr->name, eg_ptr->info, eg_ptr->g_ptr->info,
-        f_idx_str.data(), eg_ptr->g_ptr->dists[FLOW_NORMAL], eg_ptr->g_ptr->costs[FLOW_NORMAL], eg_ptr->g_ptr->when, (int)eg_ptr->y, (int)eg_ptr->x);
+    strnfmt(ge_ptr->out_val, sizeof(ge_ptr->out_val), "%s%s%s%s [%s] %x %s %d %d %d (%d,%d)", ge_ptr->s1, ge_ptr->s2, ge_ptr->s3, ge_ptr->name.data(), ge_ptr->info, ge_ptr->g_ptr->info,
+        f_idx_str.data(), ge_ptr->g_ptr->dists[FLOW_NORMAL], ge_ptr->g_ptr->costs[FLOW_NORMAL], ge_ptr->g_ptr->when, (int)ge_ptr->y, (int)ge_ptr->x);
 #endif
 }
 
@@ -538,72 +526,85 @@ static void describe_grid_monster_all(eg_type *eg_ptr)
  */
 char examine_grid(PlayerType *player_ptr, const POSITION y, const POSITION x, target_type mode, concptr info)
 {
-    eg_type tmp_eg;
-    eg_type *eg_ptr = initialize_eg_type(player_ptr, &tmp_eg, y, x, mode, info);
-    describe_scan_result(player_ptr, eg_ptr);
-    describe_target(player_ptr, eg_ptr);
-    ProcessResult next_target = describe_hallucinated_target(player_ptr, eg_ptr);
+    GridExamination tmp_eg(*player_ptr->current_floor_ptr, y, x, mode, info);
+    GridExamination *ge_ptr = &tmp_eg;
+    describe_scan_result(player_ptr, ge_ptr);
+    describe_target(player_ptr, ge_ptr);
+    ProcessResult next_target = describe_hallucinated_target(player_ptr, ge_ptr);
     switch (next_target) {
     case ProcessResult::PROCESS_FALSE:
-        return 0;
+        return '\0';
     case ProcessResult::PROCESS_TRUE:
-        return eg_ptr->query;
+        return ge_ptr->query;
     default:
         break;
     }
 
-    int16_t description_grid = describe_grid(player_ptr, eg_ptr);
+    const auto description_grid = describe_grid(player_ptr, ge_ptr);
     if (within_char_util(description_grid)) {
         return (char)description_grid;
     }
 
-    int16_t loop_description = loop_describing_grid(player_ptr, eg_ptr);
+    const auto loop_description = loop_describing_grid(player_ptr, ge_ptr);
     if (within_char_util(loop_description)) {
         return (char)loop_description;
     }
 
-    int16_t footing_items_description = sweep_footing_items(player_ptr, eg_ptr);
+    const auto footing_items_description = sweep_footing_items(player_ptr, ge_ptr);
     if (within_char_util(footing_items_description)) {
         return (char)footing_items_description;
     }
 
-    eg_ptr->feat = eg_ptr->g_ptr->get_feat_mimic();
-    if (!eg_ptr->g_ptr->is_mark() && !player_can_see_bold(player_ptr, y, x)) {
-        eg_ptr->feat = feat_none;
+    ge_ptr->feat = ge_ptr->g_ptr->get_feat_mimic();
+    if (!ge_ptr->g_ptr->is_mark() && !player_can_see_bold(player_ptr, y, x)) {
+        ge_ptr->feat = feat_none;
     }
 
-    eg_ptr->f_ptr = &terrains_info[eg_ptr->feat];
-    if (!eg_ptr->boring && eg_ptr->f_ptr->flags.has_not(TerrainCharacteristics::REMEMBER)) {
-        return (eg_ptr->query != '\r') && (eg_ptr->query != '\n') ? eg_ptr->query : 0;
+    ge_ptr->terrain_ptr = &TerrainList::get_instance()[ge_ptr->feat];
+    if (!ge_ptr->boring && ge_ptr->terrain_ptr->flags.has_not(TerrainCharacteristics::REMEMBER)) {
+        return (ge_ptr->query != '\r') && (ge_ptr->query != '\n') ? ge_ptr->query : 0;
     }
 
     /*
      * グローバル変数への代入をここで行っているので動かしたくない
      * 安全を確保できたら構造体から外すことも検討する
      */
-    eg_ptr->name = decide_target_floor(player_ptr, eg_ptr);
-    if (*eg_ptr->s2 && (eg_ptr->f_ptr->flags.has_none_of({ TerrainCharacteristics::MOVE, TerrainCharacteristics::CAN_FLY }) || eg_ptr->f_ptr->flags.has_none_of({ TerrainCharacteristics::LOS, TerrainCharacteristics::TREE }) || eg_ptr->f_ptr->flags.has(TerrainCharacteristics::TOWN))) {
-        eg_ptr->s2 = _("の中", "in ");
+    ge_ptr->name = decide_target_floor(player_ptr, ge_ptr);
+    auto is_in = ge_ptr->terrain_ptr->flags.has_none_of({ TerrainCharacteristics::MOVE, TerrainCharacteristics::CAN_FLY });
+    is_in |= ge_ptr->terrain_ptr->flags.has_none_of({ TerrainCharacteristics::LOS, TerrainCharacteristics::TREE });
+    is_in |= ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::TOWN);
+    if (*ge_ptr->s2 && is_in) {
+        ge_ptr->s2 = _("の中", "in ");
     }
 
-    if (eg_ptr->f_ptr->flags.has(TerrainCharacteristics::STORE) || eg_ptr->f_ptr->flags.has(TerrainCharacteristics::QUEST_ENTER) || (eg_ptr->f_ptr->flags.has(TerrainCharacteristics::BLDG) && !player_ptr->current_floor_ptr->inside_arena) || eg_ptr->f_ptr->flags.has(TerrainCharacteristics::ENTRANCE)) {
-        eg_ptr->s2 = _("の入口", "");
+    auto is_entrance = ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::STORE);
+    is_entrance |= ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::QUEST_ENTER);
+    is_entrance |= ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::BLDG) && !player_ptr->current_floor_ptr->inside_arena;
+    is_entrance |= ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::ENTRANCE);
+    if (is_entrance) {
+        ge_ptr->s2 = _("の入口", "");
     }
 #ifdef JP
 #else
-    else if (eg_ptr->f_ptr->flags.has(TerrainCharacteristics::FLOOR) || eg_ptr->f_ptr->flags.has(TerrainCharacteristics::TOWN) || eg_ptr->f_ptr->flags.has(TerrainCharacteristics::SHALLOW) || eg_ptr->f_ptr->flags.has(TerrainCharacteristics::DEEP)) {
-        eg_ptr->s3 = "";
-    } else {
-        eg_ptr->s3 = (is_a_vowel(eg_ptr->name[0])) ? "an " : "a ";
+    else {
+        auto is_normal_terrain = ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::FLOOR);
+        is_normal_terrain |= ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::TOWN);
+        is_normal_terrain |= ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::SHALLOW);
+        is_normal_terrain |= ge_ptr->terrain_ptr->flags.has(TerrainCharacteristics::DEEP);
+        if (is_normal_terrain) {
+            ge_ptr->s3 = "";
+        } else {
+            ge_ptr->s3 = (is_a_vowel(ge_ptr->name[0])) ? "an " : "a ";
+        }
     }
 #endif
 
-    describe_grid_monster_all(eg_ptr);
-    prt(eg_ptr->out_val, 0, 0);
+    describe_grid_monster_all(ge_ptr);
+    prt(ge_ptr->out_val, 0, 0);
     move_cursor_relative(y, x);
-    eg_ptr->query = inkey();
-    if ((eg_ptr->query != '\r') && (eg_ptr->query != '\n')) {
-        return eg_ptr->query;
+    ge_ptr->query = inkey();
+    if ((ge_ptr->query != '\r') && (ge_ptr->query != '\n')) {
+        return ge_ptr->query;
     }
 
     return 0;