OSDN Git Service

Refactor monster_desc() to avoid sprintf(). To work with the refactored monster_desc...
[hengbandforosx/hengbandosx.git] / src / core / player-processor.cpp
index 1dba4a3..a813654 100644 (file)
@@ -8,14 +8,13 @@
 #include "core/speed-table.h"
 #include "core/stuff-handler.h"
 #include "core/window-redrawer.h"
-#include "dungeon/dungeon.h"
 #include "floor/floor-save-util.h"
 #include "floor/floor-util.h"
 #include "floor/geometry.h"
 #include "floor/wild.h"
+#include "game-option/cheat-options.h"
 #include "game-option/disturbance-options.h"
 #include "game-option/map-screen-options.h"
-#include "game-option/cheat-options.h"
 #include "grid/grid.h"
 #include "inventory/pack-overflow.h"
 #include "io/cursor.h"
@@ -40,6 +39,7 @@
 #include "player-base/player-class.h"
 #include "player-info/bluemage-data-type.h"
 #include "player-info/mane-data-type.h"
+#include "player-info/samurai-data-type.h"
 #include "player-info/sniper-data-type.h"
 #include "player-status/player-energy.h"
 #include "player/attack-defense-types.h"
 #include "spell-realm/spells-hex.h"
 #include "spell-realm/spells-song.h"
 #include "status/action-setter.h"
+#include "system/dungeon-info.h"
 #include "system/floor-type-definition.h"
 #include "system/grid-type-definition.h"
-#include "system/monster-race-definition.h"
+#include "system/monster-race-info.h"
 #include "system/player-type-definition.h"
 #include "term/screen-processor.h"
+#include "timed-effect/player-blindness.h"
+#include "timed-effect/player-confusion.h"
 #include "timed-effect/player-cut.h"
+#include "timed-effect/player-hallucination.h"
+#include "timed-effect/player-paralysis.h"
 #include "timed-effect/player-stun.h"
 #include "timed-effect/timed-effects.h"
 #include "util/bit-flags-calculator.h"
 bool load = true;
 bool can_save = false;
 
-static void process_fishing(player_type *player_ptr)
+static void process_fishing(PlayerType *player_ptr)
 {
     term_xtra(TERM_XTRA_DELAY, 10);
     if (one_in_(1000)) {
-        MONRACE_IDX r_idx;
         bool success = false;
         get_mon_num_prep(player_ptr, monster_is_fishing_target, nullptr);
-        r_idx = get_mon_num(player_ptr, 0,
-            is_in_dungeon(player_ptr) ? player_ptr->current_floor_ptr->dun_level
-                                                       : wilderness[player_ptr->wilderness_y][player_ptr->wilderness_x].level,
-            0);
+        auto *floor_ptr = player_ptr->current_floor_ptr;
+        const auto wild_level = wilderness[player_ptr->wilderness_y][player_ptr->wilderness_x].level;
+        const auto level = floor_ptr->is_in_dungeon() ? floor_ptr->dun_level : wild_level;
+        const auto r_idx = get_mon_num(player_ptr, 0, level, 0);
         msg_print(nullptr);
-        if (r_idx && one_in_(2)) {
+        if (MonsterRace(r_idx).is_valid() && one_in_(2)) {
             POSITION y, x;
             y = player_ptr->y + ddy[player_ptr->fishing_dir];
             x = player_ptr->x + ddx[player_ptr->fishing_dir];
             if (place_monster_aux(player_ptr, 0, y, x, r_idx, PM_NO_KAGE)) {
-                GAME_TEXT m_name[MAX_NLEN];
-                monster_desc(player_ptr, m_name, &player_ptr->current_floor_ptr->m_list[player_ptr->current_floor_ptr->grid_array[y][x].m_idx], 0);
-                msg_format(_("%sが釣れた!", "You have a good catch!"), m_name);
+                const auto m_name = monster_desc(player_ptr, &floor_ptr->m_list[floor_ptr->grid_array[y][x].m_idx], 0);
+                msg_format(_("%sが釣れた!", "You have a good catch!"), m_name.data());
                 success = true;
             }
         }
@@ -98,7 +101,7 @@ static void process_fishing(player_type *player_ptr)
     }
 }
 
-bool continuous_action_running(player_type *player_ptr)
+bool continuous_action_running(PlayerType *player_ptr)
 {
     return player_ptr->running || travel.run || command_rep || (player_ptr->action == ACTION_REST) || (player_ptr->action == ACTION_FISH);
 }
@@ -110,7 +113,7 @@ bool continuous_action_running(player_type *player_ptr)
  * must come first just in case somebody manages to corrupt\n
  * the savefiles by clever use of menu commands or something.\n
  */
-void process_player(player_type *player_ptr)
+void process_player(PlayerType *player_ptr)
 {
     if (player_ptr->hack_mutation) {
         msg_print(_("何か変わった気がする!", "You feel different!"));
@@ -126,21 +129,23 @@ void process_player(player_type *player_ptr)
 
     if (player_ptr->phase_out) {
         for (MONSTER_IDX m_idx = 1; m_idx < player_ptr->current_floor_ptr->m_max; m_idx++) {
-            monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
-            if (!monster_is_valid(m_ptr))
+            auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
+            if (!m_ptr->is_valid()) {
                 continue;
+            }
 
-            m_ptr->mflag2.set({MFLAG2::MARK, MFLAG2::SHOW});
+            m_ptr->mflag2.set({ MonsterConstantFlagType::MARK, MonsterConstantFlagType::SHOW });
             update_monster(player_ptr, m_idx, false);
         }
 
-        WorldTurnProcessor(player_ptr).print_time();        
+        WorldTurnProcessor(player_ptr).print_time();
     } else if (!(load && player_ptr->energy_need <= 0)) {
-        player_ptr->energy_need -= SPEED_TO_ENERGY(player_ptr->pspeed);
+        player_ptr->energy_need -= speed_to_energy(player_ptr->pspeed);
     }
 
-    if (player_ptr->energy_need > 0)
+    if (player_ptr->energy_need > 0) {
         return;
+    }
     if (!command_rep) {
         WorldTurnProcessor(player_ptr).print_time();
     }
@@ -155,19 +160,15 @@ void process_player(player_type *player_ptr)
                 set_action(player_ptr, ACTION_NONE);
             }
         } else if (player_ptr->resting == COMMAND_ARG_REST_UNTIL_DONE) {
-            auto effects = player_ptr->effects();
-            auto is_stunned = effects->stun()->is_stunned();
-            auto is_cut = effects->cut()->is_cut();
-            if ((player_ptr->chp == player_ptr->mhp) && (player_ptr->csp >= player_ptr->msp) && !player_ptr->blind && !player_ptr->confused
-                && !player_ptr->poisoned && !player_ptr->afraid && !is_stunned && !is_cut && !player_ptr->slow
-                && !player_ptr->paralyzed && !player_ptr->hallucinated && !player_ptr->word_recall && !player_ptr->alter_reality) {
+            if (player_ptr->is_fully_healthy()) {
                 set_action(player_ptr, ACTION_NONE);
             }
         }
     }
 
-    if (player_ptr->action == ACTION_FISH)
+    if (player_ptr->action == ACTION_FISH) {
         process_fishing(player_ptr);
+    }
 
     if (check_abort) {
         if (continuous_action_running(player_ptr)) {
@@ -180,40 +181,37 @@ void process_player(player_type *player_ptr)
         }
     }
 
-    if (player_ptr->riding && !player_ptr->confused && !player_ptr->blind) {
-        monster_type *m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
-        monster_race *r_ptr = &r_info[m_ptr->r_idx];
-        if (monster_csleep_remaining(m_ptr)) {
-            GAME_TEXT m_name[MAX_NLEN];
+    const auto effects = player_ptr->effects();
+    if (player_ptr->riding && !effects->confusion()->is_confused() && !effects->blindness()->is_blind()) {
+        auto *m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->riding];
+        auto *r_ptr = &monraces_info[m_ptr->r_idx];
+        if (m_ptr->is_asleep()) {
+            const auto m_name = monster_desc(player_ptr, m_ptr, 0);
             (void)set_monster_csleep(player_ptr, player_ptr->riding, 0);
-            monster_desc(player_ptr, m_name, m_ptr, 0);
-            msg_format(_("%^sを起こした。", "You have woken %s up."), m_name);
+            msg_format(_("%^sを起こした。", "You have woken %s up."), m_name.data());
         }
 
-        if (monster_stunned_remaining(m_ptr)) {
+        if (m_ptr->is_stunned()) {
             if (set_monster_stunned(player_ptr, player_ptr->riding,
-                    (randint0(r_ptr->level) < player_ptr->skill_exp[SKILL_RIDING]) ? 0 : (monster_stunned_remaining(m_ptr) - 1))) {
-                GAME_TEXT m_name[MAX_NLEN];
-                monster_desc(player_ptr, m_name, m_ptr, 0);
-                msg_format(_("%^sを朦朧状態から立ち直らせた。", "%^s is no longer stunned."), m_name);
+                    (randint0(r_ptr->level) < player_ptr->skill_exp[PlayerSkillKindType::RIDING]) ? 0 : (m_ptr->get_remaining_stun() - 1))) {
+                const auto m_name = monster_desc(player_ptr, m_ptr, 0);
+                msg_format(_("%^sを朦朧状態から立ち直らせた。", "%^s is no longer stunned."), m_name.data());
             }
         }
 
-        if (monster_confused_remaining(m_ptr)) {
+        if (m_ptr->is_confused()) {
             if (set_monster_confused(player_ptr, player_ptr->riding,
-                    (randint0(r_ptr->level) < player_ptr->skill_exp[SKILL_RIDING]) ? 0 : (monster_confused_remaining(m_ptr) - 1))) {
-                GAME_TEXT m_name[MAX_NLEN];
-                monster_desc(player_ptr, m_name, m_ptr, 0);
-                msg_format(_("%^sを混乱状態から立ち直らせた。", "%^s is no longer confused."), m_name);
+                    (randint0(r_ptr->level) < player_ptr->skill_exp[PlayerSkillKindType::RIDING]) ? 0 : (m_ptr->get_remaining_confusion() - 1))) {
+                const auto m_name = monster_desc(player_ptr, m_ptr, 0);
+                msg_format(_("%^sを混乱状態から立ち直らせた。", "%^s is no longer confused."), m_name.data());
             }
         }
 
-        if (monster_fear_remaining(m_ptr)) {
+        if (m_ptr->is_fearful()) {
             if (set_monster_monfear(player_ptr, player_ptr->riding,
-                    (randint0(r_ptr->level) < player_ptr->skill_exp[SKILL_RIDING]) ? 0 : (monster_fear_remaining(m_ptr) - 1))) {
-                GAME_TEXT m_name[MAX_NLEN];
-                monster_desc(player_ptr, m_name, m_ptr, 0);
-                msg_format(_("%^sを恐怖から立ち直らせた。", "%^s is no longer afraid."), m_name);
+                    (randint0(r_ptr->level) < player_ptr->skill_exp[PlayerSkillKindType::RIDING]) ? 0 : (m_ptr->get_remaining_fear() - 1))) {
+                const auto m_name = monster_desc(player_ptr, m_ptr, 0);
+                msg_format(_("%^sを恐怖から立ち直らせた。", "%^s is no longer fearful."), m_name.data());
             }
         }
 
@@ -221,14 +219,16 @@ void process_player(player_type *player_ptr)
     }
 
     load = false;
-    if (player_ptr->lightspeed)
+    if (player_ptr->lightspeed) {
         set_lightspeed(player_ptr, player_ptr->lightspeed - 1, true);
+    }
 
-    if ((player_ptr->pclass == CLASS_FORCETRAINER) && get_current_ki(player_ptr)) {
-        if (get_current_ki(player_ptr) < 40)
+    if (PlayerClass(player_ptr).equals(PlayerClassType::FORCETRAINER) && get_current_ki(player_ptr)) {
+        if (get_current_ki(player_ptr) < 40) {
             set_current_ki(player_ptr, true, 0);
-        else
+        } else {
             set_current_ki(player_ptr, false, -40);
+        }
         player_ptr->update |= (PU_BONUS);
     }
 
@@ -247,14 +247,12 @@ void process_player(player_type *player_ptr)
         player_ptr->redraw |= PR_MANA;
     }
 
-    if (player_ptr->special_defense & KATA_MASK) {
-        if (player_ptr->special_defense & KATA_MUSOU) {
-            if (player_ptr->csp < 3) {
-                set_action(player_ptr, ACTION_NONE);
-            } else {
-                player_ptr->csp -= 2;
-                player_ptr->redraw |= (PR_MANA);
-            }
+    if (PlayerClass(player_ptr).samurai_stance_is(SamuraiStanceType::MUSOU)) {
+        if (player_ptr->csp < 3) {
+            set_action(player_ptr, ACTION_NONE);
+        } else {
+            player_ptr->csp -= 2;
+            player_ptr->redraw |= (PR_MANA);
         }
     }
 
@@ -268,28 +266,31 @@ void process_player(player_type *player_ptr)
         update_monsters(player_ptr, false);
         handle_stuff(player_ptr);
         move_cursor_relative(player_ptr->y, player_ptr->x);
-        if (fresh_before)
+        if (fresh_before) {
             term_fresh_force();
+        }
 
         pack_overflow(player_ptr);
-        if (!command_new)
+        if (!command_new) {
             command_see = false;
+        }
 
         PlayerEnergy energy(player_ptr);
         energy.reset_player_turn();
-        auto effects = player_ptr->effects();
-        auto is_unconscious = effects->stun()->get_rank() == PlayerStunRank::UNCONSCIOUS;
+        auto is_knocked_out = effects->stun()->is_knocked_out();
+        auto is_paralyzed = effects->paralysis()->is_paralyzed();
         if (player_ptr->phase_out) {
             move_cursor_relative(player_ptr->y, player_ptr->x);
             command_cmd = SPECIAL_KEY_BUILDING;
             process_command(player_ptr);
-        } else if ((player_ptr->paralyzed || is_unconscious) && !cheat_immortal) {
+        } else if ((is_paralyzed || is_knocked_out) && !cheat_immortal) {
             energy.set_player_turn_energy(100);
         } else if (player_ptr->action == ACTION_REST) {
             if (player_ptr->resting > 0) {
                 player_ptr->resting--;
-                if (!player_ptr->resting)
+                if (!player_ptr->resting) {
                     set_action(player_ptr, ACTION_NONE);
+                }
                 player_ptr->redraw |= (PR_STATE);
             }
 
@@ -314,7 +315,7 @@ void process_player(player_type *player_ptr)
             window_stuff(player_ptr);
 
             can_save = true;
-            request_command(player_ptr, false);
+            InputKeyRequestor(player_ptr, false).request_command();
             can_save = false;
             process_command(player_ptr);
         }
@@ -327,55 +328,60 @@ void process_player(player_type *player_ptr)
                 player_ptr->energy_need += (int16_t)((int32_t)player_ptr->energy_use * ENERGY_NEED() / 100L);
             }
 
-            if (player_ptr->hallucinated)
+            if (effects->hallucination()->is_hallucinated()) {
                 player_ptr->redraw |= (PR_MAP);
+            }
 
             for (MONSTER_IDX m_idx = 1; m_idx < player_ptr->current_floor_ptr->m_max; m_idx++) {
-                monster_type *m_ptr;
-                monster_race *r_ptr;
+                MonsterEntity *m_ptr;
+                MonsterRaceInfo *r_ptr;
                 m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
-                if (!monster_is_valid(m_ptr))
+                if (!m_ptr->is_valid()) {
                     continue;
+                }
 
-                r_ptr = &r_info[m_ptr->ap_r_idx];
+                r_ptr = &monraces_info[m_ptr->ap_r_idx];
 
                 // モンスターのシンボル/カラーの更新
-                if (m_ptr->ml && any_bits(r_ptr->flags1, (RF1_ATTR_MULTI | RF1_SHAPECHANGER))) {
+                if (m_ptr->ml && r_ptr->visual_flags.has_any_of({ MonsterVisualType::MULTI_COLOR, MonsterVisualType::SHAPECHANGER })) {
                     lite_spot(player_ptr, m_ptr->fy, m_ptr->fx);
                 }
 
                 // 出現して即魔法を使わないようにするフラグを落とす処理
-                if (m_ptr->mflag.has(MFLAG::PREVENT_MAGIC)) {
-                    m_ptr->mflag.reset(MFLAG::PREVENT_MAGIC);
+                if (m_ptr->mflag.has(MonsterTemporaryFlagType::PREVENT_MAGIC)) {
+                    m_ptr->mflag.reset(MonsterTemporaryFlagType::PREVENT_MAGIC);
                 }
 
-                if (m_ptr->mflag.has(MFLAG::SANITY_BLAST)) {
-                    m_ptr->mflag.reset(MFLAG::SANITY_BLAST);
+                if (m_ptr->mflag.has(MonsterTemporaryFlagType::SANITY_BLAST)) {
+                    m_ptr->mflag.reset(MonsterTemporaryFlagType::SANITY_BLAST);
                     sanity_blast(player_ptr, m_ptr, false);
                 }
 
                 // 感知中のモンスターのフラグを落とす処理
                 // 感知したターンはMFLAG2_SHOWを落とし、次のターンに感知中フラグのMFLAG2_MARKを落とす
-                if (m_ptr->mflag2.has(MFLAG2::MARK)) {
-                    if (m_ptr->mflag2.has(MFLAG2::SHOW)) {
-                        m_ptr->mflag2.reset(MFLAG2::SHOW);
+                if (m_ptr->mflag2.has(MonsterConstantFlagType::MARK)) {
+                    if (m_ptr->mflag2.has(MonsterConstantFlagType::SHOW)) {
+                        m_ptr->mflag2.reset(MonsterConstantFlagType::SHOW);
                     } else {
-                        m_ptr->mflag2.reset(MFLAG2::MARK);
+                        m_ptr->mflag2.reset(MonsterConstantFlagType::MARK);
                         m_ptr->ml = false;
                         update_monster(player_ptr, m_idx, false);
-                        if (player_ptr->health_who == m_idx)
+                        if (player_ptr->health_who == m_idx) {
                             player_ptr->redraw |= (PR_HEALTH);
-                        if (player_ptr->riding == m_idx)
+                        }
+                        if (player_ptr->riding == m_idx) {
                             player_ptr->redraw |= (PR_UHEALTH);
+                        }
 
                         lite_spot(player_ptr, m_ptr->fy, m_ptr->fx);
                     }
                 }
             }
 
-            if (player_ptr->pclass == CLASS_IMITATOR) {
+            if (PlayerClass(player_ptr).equals(PlayerClassType::IMITATOR)) {
                 auto mane_data = PlayerClass(player_ptr).get_specific_data<mane_data_type>();
-                if (static_cast<int>(mane_data->mane_list.size()) > (player_ptr->lev > 44 ? 3 : player_ptr->lev > 29 ? 2 : 1)) {
+                if (static_cast<int>(mane_data->mane_list.size()) > (player_ptr->lev > 44 ? 3 : player_ptr->lev > 29 ? 2
+                                                                                                                     : 1)) {
                     mane_data->mane_list.pop_front();
                 }
 
@@ -409,11 +415,13 @@ void process_player(player_type *player_ptr)
         }
 
         auto sniper_data = PlayerClass(player_ptr).get_specific_data<sniper_data_type>();
-        if (player_ptr->energy_use && sniper_data && sniper_data->reset_concent)
+        if (player_ptr->energy_use && sniper_data && sniper_data->reset_concent) {
             reset_concentration(player_ptr, true);
+        }
 
-        if (player_ptr->leaving)
+        if (player_ptr->leaving) {
             break;
+        }
     }
 
     update_smell(player_ptr->current_floor_ptr, player_ptr);
@@ -422,14 +430,15 @@ void process_player(player_type *player_ptr)
 /*!
  * @brief プレイヤーの行動エネルギーが充填される(=プレイヤーのターンが回る)毎に行われる処理  / process the effects per 100 energy at player speed.
  */
-void process_upkeep_with_speed(player_type *player_ptr)
+void process_upkeep_with_speed(PlayerType *player_ptr)
 {
     if (!load && player_ptr->enchant_energy_need > 0 && !player_ptr->leaving) {
-        player_ptr->enchant_energy_need -= SPEED_TO_ENERGY(player_ptr->pspeed);
+        player_ptr->enchant_energy_need -= speed_to_energy(player_ptr->pspeed);
     }
 
-    if (player_ptr->enchant_energy_need > 0)
+    if (player_ptr->enchant_energy_need > 0) {
         return;
+    }
 
     while (player_ptr->enchant_energy_need <= 0) {
         if (!load) {