[Refactor] 技能の定義を enum class にする

技能の定義の列挙型を enum skill_idx から enum class PlayerSkillKindType
にする。

diff --git a/src/cmd-action/cmd-attack.cpp b/src/cmd-action/cmd-attack.cpp
index 27fd36c..1be06dd 100644 (file)
--- a/src/cmd-action/cmd-attack.cpp
+++ b/src/cmd-action/cmd-attack.cpp
@@ -251,7 +251,7 @@ bool do_cmd_attack(player_type *player_ptr, POSITION y, POSITION x, combat_optio
     }
 
     if (can_attack_with_main_hand(player_ptr) && can_attack_with_sub_hand(player_ptr)) {
-        if (((player_ptr->skill_exp[SKILL_TWO_WEAPON] - 1000) / 200) < r_ptr->level) {
+        if (((player_ptr->skill_exp[PlayerSkillKindType::TWO_WEAPON] - 1000) / 200) < r_ptr->level) {
             PlayerSkill(player_ptr).gain_two_weapon_skill_exp();
         }
     }

diff --git a/src/cmd-action/cmd-pet.cpp b/src/cmd-action/cmd-pet.cpp
index 01cfab4..83e4c6f 100644 (file)
--- a/src/cmd-action/cmd-pet.cpp
+++ b/src/cmd-action/cmd-pet.cpp
@@ -264,7 +264,7 @@ bool do_cmd_riding(player_type *player_ptr, bool force)
 
             return false;
         }
-        if (r_info[m_ptr->r_idx].level > randint1((player_ptr->skill_exp[SKILL_RIDING] / 50 + player_ptr->lev / 2 + 20))) {
+        if (r_info[m_ptr->r_idx].level > randint1((player_ptr->skill_exp[PlayerSkillKindType::RIDING] / 50 + player_ptr->lev / 2 + 20))) {
             msg_print(_("うまく乗れなかった。", "You failed to ride."));
             PlayerEnergy(player_ptr).set_player_turn_energy(100);
             return false;

diff --git a/src/core/player-processor.cpp b/src/core/player-processor.cpp
index d89e73b..4db8864 100644 (file)
--- a/src/core/player-processor.cpp
+++ b/src/core/player-processor.cpp
@@ -193,7 +193,7 @@ void process_player(player_type *player_ptr)
 
         if (monster_stunned_remaining(m_ptr)) {
             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))) {
+                    (randint0(r_ptr->level) < player_ptr->skill_exp[PlayerSkillKindType::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);
@@ -202,7 +202,7 @@ void process_player(player_type *player_ptr)
 
         if (monster_confused_remaining(m_ptr)) {
             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))) {
+                    (randint0(r_ptr->level) < player_ptr->skill_exp[PlayerSkillKindType::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);
@@ -211,7 +211,7 @@ void process_player(player_type *player_ptr)
 
         if (monster_fear_remaining(m_ptr)) {
             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))) {
+                    (randint0(r_ptr->level) < player_ptr->skill_exp[PlayerSkillKindType::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);

diff --git a/src/info-reader/skill-reader.cpp b/src/info-reader/skill-reader.cpp
index 3587b88..40e4440 100644 (file)
--- a/src/info-reader/skill-reader.cpp
+++ b/src/info-reader/skill-reader.cpp
@@ -59,7 +59,7 @@ errr parse_s_info(std::string_view buf, angband_header *head)
         if (!PlayerSkill::valid_weapon_exp(start) || !PlayerSkill::valid_weapon_exp(max) || start > max)
             return PARSE_ERROR_INVALID_FLAG;
 
-        auto skill = SKILL_MARTIAL_ARTS + num;
+        auto skill = PlayerSkillKindType::MARTIAL_ARTS + num;
         s_ptr->s_start[skill] = static_cast<SUB_EXP>(start);
         s_ptr->s_max[skill] = static_cast<SUB_EXP>(max);
     } else

diff --git a/src/knowledge/knowledge-experiences.cpp b/src/knowledge/knowledge-experiences.cpp
index 485d17c..1aa8dc0 100644 (file)
--- a/src/knowledge/knowledge-experiences.cpp
+++ b/src/knowledge/knowledge-experiences.cpp
@@ -31,7 +31,7 @@ void do_cmd_knowledge_weapon_exp(player_type *player_ptr)
     if (!open_temporary_file(&fff, file_name))
         return;
 
-    for (auto tval : {ItemKindType::SWORD, ItemKindType::POLEARM, ItemKindType::HAFTED, ItemKindType::DIGGING, ItemKindType::BOW}) {
+    for (auto tval : { ItemKindType::SWORD, ItemKindType::POLEARM, ItemKindType::HAFTED, ItemKindType::DIGGING, ItemKindType::BOW }) {
         for (int num = 0; num < 64; num++) {
             char tmp[30];
             for (const auto &k_ref : k_info) {
@@ -150,9 +150,6 @@ void do_cmd_knowledge_spell_exp(player_type *player_ptr)
  */
 void do_cmd_knowledge_skill_exp(player_type *player_ptr)
 {
-    const char *skill_name[SKILL_MAX] = { _("マーシャルアーツ", "Martial Arts    "), _("二刀流          ", "Dual Wielding   "),
-        _("乗馬            ", "Riding          "), _("盾              ", "Shield          ") };
-
     FILE *fff = nullptr;
     char file_name[FILE_NAME_SIZE];
     if (!open_temporary_file(&fff, file_name))
@@ -161,14 +158,14 @@ void do_cmd_knowledge_skill_exp(player_type *player_ptr)
     for (auto i : PLAYER_SKILL_KIND_TYPE_RANGE) {
         SUB_EXP skill_exp = player_ptr->skill_exp[i];
         SUB_EXP skill_max = s_info[enum2i(player_ptr->pclass)].s_max[i];
-        fprintf(fff, "%-20s ", skill_name[i]);
+        fprintf(fff, "%-20s ", PlayerSkill::skill_name(i));
         if (show_actual_value)
             fprintf(fff, "%4d/%4d ", std::min(skill_exp, skill_max), skill_max);
         if (skill_exp >= skill_max)
             fprintf(fff, "!");
         else
             fprintf(fff, " ");
-        fprintf(fff, "%s", exp_level_str[(i == SKILL_RIDING) ? PlayerSkill::riding_exp_level(skill_exp) : PlayerSkill::weapon_exp_level(skill_exp)]);
+        fprintf(fff, "%s", exp_level_str[(i == PlayerSkillKindType::RIDING) ? PlayerSkill::riding_exp_level(skill_exp) : PlayerSkill::weapon_exp_level(skill_exp)]);
         if (cheat_xtra)
             fprintf(fff, " %d", skill_exp);
         fprintf(fff, "\n");

diff --git a/src/load/load-zangband.cpp b/src/load/load-zangband.cpp
index 1323001..53e2b55 100644 (file)
--- a/src/load/load-zangband.cpp
+++ b/src/load/load-zangband.cpp
@@ -90,9 +90,9 @@ void set_zangband_realm(player_type *player_ptr)
 void set_zangband_skill(player_type *player_ptr)
 {
     if (player_ptr->pclass != PlayerClassType::BEASTMASTER)
-        player_ptr->skill_exp[SKILL_RIDING] /= 2;
+        player_ptr->skill_exp[PlayerSkillKindType::RIDING] /= 2;
 
-    player_ptr->skill_exp[SKILL_RIDING] = std::min(player_ptr->skill_exp[SKILL_RIDING], s_info[enum2i(player_ptr->pclass)].s_max[SKILL_RIDING]);
+    player_ptr->skill_exp[PlayerSkillKindType::RIDING] = std::min(player_ptr->skill_exp[PlayerSkillKindType::RIDING], s_info[enum2i(player_ptr->pclass)].s_max[PlayerSkillKindType::RIDING]);
 }
 
 void set_zangband_race(player_type *player_ptr)

diff --git a/src/mind/mind-cavalry.cpp b/src/mind/mind-cavalry.cpp
index 211682e..506873a 100644 (file)
--- a/src/mind/mind-cavalry.cpp
+++ b/src/mind/mind-cavalry.cpp
@@ -55,9 +55,9 @@ bool rodeo(player_type *player_ptr)
         rlev = rlev * 3 / 2;
     if (rlev > 60)
         rlev = 60 + (rlev - 60) / 2;
-    if ((randint1(player_ptr->skill_exp[SKILL_RIDING] / 120 + player_ptr->lev * 2 / 3) > rlev) && one_in_(2)
-        && !player_ptr->current_floor_ptr->inside_arena && !player_ptr->phase_out && !(r_ptr->flags7 & (RF7_GUARDIAN)) && !(r_ptr->flags1 & (RF1_QUESTOR))
-        && (rlev < player_ptr->lev * 3 / 2 + randint0(player_ptr->lev / 5))) {
+    if ((randint1(player_ptr->skill_exp[PlayerSkillKindType::RIDING] / 120 + player_ptr->lev * 2 / 3) > rlev) && one_in_(2) &&
+        !player_ptr->current_floor_ptr->inside_arena && !player_ptr->phase_out && !(r_ptr->flags7 & (RF7_GUARDIAN)) && !(r_ptr->flags1 & (RF1_QUESTOR)) &&
+        (rlev < player_ptr->lev * 3 / 2 + randint0(player_ptr->lev / 5))) {
         msg_format(_("%sを手なずけた。", "You tame %s."), m_name);
         set_pet(player_ptr, m_ptr);
     } else {

diff --git a/src/monster-attack/monster-attack-player.cpp b/src/monster-attack/monster-attack-player.cpp
index 68657c5..30c4768 100644 (file)
--- a/src/monster-attack/monster-attack-player.cpp
+++ b/src/monster-attack/monster-attack-player.cpp
@@ -279,8 +279,8 @@ static void gain_armor_exp(player_type *player_ptr, monap_type *monap_ptr)
         return;
     }
 
-    auto cur = player_ptr->skill_exp[SKILL_SHIELD];
-    auto max = s_info[enum2i(player_ptr->pclass)].s_max[SKILL_SHIELD];
+    auto cur = player_ptr->skill_exp[PlayerSkillKindType::SHIELD];
+    auto max = s_info[enum2i(player_ptr->pclass)].s_max[PlayerSkillKindType::SHIELD];
     if (cur >= max) {
         return;
     }
@@ -293,7 +293,7 @@ static void gain_armor_exp(player_type *player_ptr, monap_type *monap_ptr)
         increment += 1 + addition;
     }
 
-    player_ptr->skill_exp[SKILL_SHIELD] = std::min<short>(max, cur + increment);
+    player_ptr->skill_exp[PlayerSkillKindType::SHIELD] = std::min<short>(max, cur + increment);
     player_ptr->update |= (PU_BONUS);
 }
 

diff --git a/src/monster/monster-processor.cpp b/src/monster/monster-processor.cpp
index b69aa11..b1e7377 100644 (file)
--- a/src/monster/monster-processor.cpp
+++ b/src/monster/monster-processor.cpp
@@ -325,7 +325,7 @@ void process_angar(player_type *player_ptr, MONSTER_IDX m_idx, bool see_m)
 
     /* When riding a hostile alignment pet */
     if (player_ptr->riding == m_idx) {
-        if (abs(player_ptr->alignment / 10) < randint0(player_ptr->skill_exp[SKILL_RIDING]))
+        if (abs(player_ptr->alignment / 10) < randint0(player_ptr->skill_exp[PlayerSkillKindType::RIDING]))
             return;
 
         msg_format(_("%^sが突然暴れだした！", "%^s suddenly begins unruly!"), m_name);

diff --git a/src/pet/pet-fall-off.cpp b/src/pet/pet-fall-off.cpp
index 5350ca3..8d146a6 100644 (file)
--- a/src/pet/pet-fall-off.cpp
+++ b/src/pet/pet-fall-off.cpp
@@ -58,7 +58,7 @@ static bool calc_fall_off_possibility(player_type *player_ptr, const HIT_POINT d
     if (force)
         return true;
 
-    auto cur = player_ptr->skill_exp[SKILL_RIDING];
+    auto cur = player_ptr->skill_exp[PlayerSkillKindType::RIDING];
 
     int fall_off_level = r_ptr->level;
     if (player_ptr->riding_ryoute)

diff --git a/src/player-status/player-speed.cpp b/src/player-status/player-speed.cpp
index 668e201..5b89edd 100644 (file)
--- a/src/player-status/player-speed.cpp
+++ b/src/player-status/player-speed.cpp
@@ -285,14 +285,14 @@ int16_t PlayerSpeed::riding_value()
     }
 
     if (riding_m_ptr->mspeed > 110) {
-        result = (int16_t)((speed - 110) * (this->player_ptr->skill_exp[SKILL_RIDING] * 3 + this->player_ptr->lev * 160L - 10000L) / (22000L));
+        result = (int16_t)((speed - 110) * (this->player_ptr->skill_exp[PlayerSkillKindType::RIDING] * 3 + this->player_ptr->lev * 160L - 10000L) / (22000L));
         if (result < 0)
             result = 0;
     } else {
         result = speed - 110;
     }
 
-    result += (this->player_ptr->skill_exp[SKILL_RIDING] + this->player_ptr->lev * 160L) / 3200;
+    result += (this->player_ptr->skill_exp[PlayerSkillKindType::RIDING] + this->player_ptr->lev * 160L) / 3200;
 
     if (monster_fast_remaining(riding_m_ptr))
         result += 10;

diff --git a/src/player/player-skill.cpp b/src/player/player-skill.cpp
index 64546a1..3f815bc 100644 (file)
--- a/src/player/player-skill.cpp
+++ b/src/player/player-skill.cpp
@@ -198,6 +198,24 @@ int PlayerSkill::spell_exp_level(int spell_exp)
         return EXP_LEVEL_MASTER;
 }
 
+concptr PlayerSkill::skill_name(PlayerSkillKindType skill)
+{
+    switch (skill) {
+    case PlayerSkillKindType::MARTIAL_ARTS:
+        return _("マーシャルアーツ", "Martial Arts");
+    case PlayerSkillKindType::TWO_WEAPON:
+        return _("二刀流", "Dual Wielding");
+    case PlayerSkillKindType::RIDING:
+        return _("乗馬", "Riding");
+    case PlayerSkillKindType::SHIELD:
+        return _("盾", "Shield");
+    case PlayerSkillKindType::MAX:
+        break;
+    }
+
+    return _("不明", "Unknown");
+}
+
 void PlayerSkill::gain_melee_weapon_exp(const object_type *o_ptr)
 {
     const GainAmountList gain_amount_list{ 80, 10, 1, (one_in_(2) ? 1 : 0) };
@@ -228,24 +246,24 @@ void PlayerSkill::gain_range_weapon_exp(const object_type *o_ptr)
 
 void PlayerSkill::gain_martial_arts_skill_exp()
 {
-    if (this->player_ptr->skill_exp[SKILL_MARTIAL_ARTS] < s_info[enum2i(this->player_ptr->pclass)].s_max[SKILL_MARTIAL_ARTS]) {
+    if (this->player_ptr->skill_exp[PlayerSkillKindType::MARTIAL_ARTS] < s_info[enum2i(this->player_ptr->pclass)].s_max[PlayerSkillKindType::MARTIAL_ARTS]) {
         const GainAmountList gain_amount_list{ 40, 5, 1, (one_in_(3) ? 1 : 0) };
-        gain_attack_skill_exp(this->player_ptr, this->player_ptr->skill_exp[SKILL_MARTIAL_ARTS], gain_amount_list);
+        gain_attack_skill_exp(this->player_ptr, this->player_ptr->skill_exp[PlayerSkillKindType::MARTIAL_ARTS], gain_amount_list);
     }
 }
 
 void PlayerSkill::gain_two_weapon_skill_exp()
 {
-    if (this->player_ptr->skill_exp[SKILL_TWO_WEAPON] < s_info[enum2i(this->player_ptr->pclass)].s_max[SKILL_TWO_WEAPON]) {
+    if (this->player_ptr->skill_exp[PlayerSkillKindType::TWO_WEAPON] < s_info[enum2i(this->player_ptr->pclass)].s_max[PlayerSkillKindType::TWO_WEAPON]) {
         const GainAmountList gain_amount_list{ 80, 4, 1, (one_in_(3) ? 1 : 0) };
-        gain_attack_skill_exp(this->player_ptr, this->player_ptr->skill_exp[SKILL_TWO_WEAPON], gain_amount_list);
+        gain_attack_skill_exp(this->player_ptr, this->player_ptr->skill_exp[PlayerSkillKindType::TWO_WEAPON], gain_amount_list);
     }
 }
 
 void PlayerSkill::gain_riding_skill_exp_on_melee_attack(const monster_race *r_ptr)
 {
-    auto now_exp = this->player_ptr->skill_exp[SKILL_RIDING];
-    auto max_exp = s_info[enum2i(this->player_ptr->pclass)].s_max[SKILL_RIDING];
+    auto now_exp = this->player_ptr->skill_exp[PlayerSkillKindType::RIDING];
+    auto max_exp = s_info[enum2i(this->player_ptr->pclass)].s_max[PlayerSkillKindType::RIDING];
     if (now_exp >= max_exp)
         return;
 
@@ -262,27 +280,27 @@ void PlayerSkill::gain_riding_skill_exp_on_melee_attack(const monster_race *r_pt
             inc += 1;
     }
 
-    this->player_ptr->skill_exp[SKILL_RIDING] = std::min<SUB_EXP>(max_exp, now_exp + inc);
+    this->player_ptr->skill_exp[PlayerSkillKindType::RIDING] = std::min<SUB_EXP>(max_exp, now_exp + inc);
     set_bits(this->player_ptr->update, PU_BONUS);
 }
 
 void PlayerSkill::gain_riding_skill_exp_on_range_attack()
 {
-    auto now_exp = this->player_ptr->skill_exp[SKILL_RIDING];
-    auto max_exp = s_info[enum2i(this->player_ptr->pclass)].s_max[SKILL_RIDING];
+    auto now_exp = this->player_ptr->skill_exp[PlayerSkillKindType::RIDING];
+    auto max_exp = s_info[enum2i(this->player_ptr->pclass)].s_max[PlayerSkillKindType::RIDING];
     if (now_exp >= max_exp)
         return;
 
-    if (((this->player_ptr->skill_exp[SKILL_RIDING] - (RIDING_EXP_BEGINNER * 2)) / 200 < r_info[this->player_ptr->current_floor_ptr->m_list[this->player_ptr->riding].r_idx].level) && one_in_(2)) {
-        this->player_ptr->skill_exp[SKILL_RIDING] += 1;
+    if (((this->player_ptr->skill_exp[PlayerSkillKindType::RIDING] - (RIDING_EXP_BEGINNER * 2)) / 200 < r_info[this->player_ptr->current_floor_ptr->m_list[this->player_ptr->riding].r_idx].level) && one_in_(2)) {
+        this->player_ptr->skill_exp[PlayerSkillKindType::RIDING] += 1;
         set_bits(this->player_ptr->update, PU_BONUS);
     }
 }
 
 void PlayerSkill::gain_riding_skill_exp_on_fall_off_check(HIT_POINT dam)
 {
-    auto now_exp = this->player_ptr->skill_exp[SKILL_RIDING];
-    auto max_exp = s_info[enum2i(this->player_ptr->pclass)].s_max[SKILL_RIDING];
+    auto now_exp = this->player_ptr->skill_exp[PlayerSkillKindType::RIDING];
+    auto max_exp = s_info[enum2i(this->player_ptr->pclass)].s_max[PlayerSkillKindType::RIDING];
     if (now_exp >= max_exp || max_exp <= 1000)
         return;
 
@@ -297,7 +315,7 @@ void PlayerSkill::gain_riding_skill_exp_on_fall_off_check(HIT_POINT dam)
     else
         inc += 1;
 
-    this->player_ptr->skill_exp[SKILL_RIDING] = std::min<SUB_EXP>(max_exp, now_exp + inc);
+    this->player_ptr->skill_exp[PlayerSkillKindType::RIDING] = std::min<SUB_EXP>(max_exp, now_exp + inc);
     set_bits(this->player_ptr->update, PU_BONUS);
 }
 

diff --git a/src/player/player-skill.h b/src/player/player-skill.h
index cc1b031..06f063c 100644 (file)
--- a/src/player/player-skill.h
+++ b/src/player/player-skill.h
@@ -9,15 +9,15 @@
 #include <string>
 #include <vector>
 
-enum skill_idx {
-    SKILL_MARTIAL_ARTS = 0,
-    SKILL_TWO_WEAPON = 1,
-    SKILL_RIDING = 2,
-    SKILL_SHIELD = 3,
-    SKILL_MAX = 4,
+enum class PlayerSkillKindType {
+    MARTIAL_ARTS = 0,
+    TWO_WEAPON = 1,
+    RIDING = 2,
+    SHIELD = 3,
+    MAX,
 };
 
-constexpr auto PLAYER_SKILL_KIND_TYPE_RANGE = EnumRange(SKILL_MARTIAL_ARTS, SKILL_SHIELD);
+constexpr auto PLAYER_SKILL_KIND_TYPE_RANGE = EnumRange(PlayerSkillKindType::MARTIAL_ARTS, PlayerSkillKindType::SHIELD);
 
 /* Proficiency level */
 #define EXP_LEVEL_UNSKILLED 0
@@ -36,8 +36,8 @@ enum class ItemKindType : short;
 typedef struct skill_table {
     std::map<ItemKindType, std::array<SUB_EXP, 64>> w_start{}; /* start weapon exp */
     std::map<ItemKindType, std::array<SUB_EXP, 64>> w_max{}; /* max weapon exp */
-    std::map<skill_idx, SUB_EXP> s_start{}; /* start skill */
-    std::map<skill_idx, SUB_EXP> s_max{}; /* max skill */
+    std::map<PlayerSkillKindType, SUB_EXP> s_start{}; /* start skill */
+    std::map<PlayerSkillKindType, SUB_EXP> s_max{}; /* max skill */
 } skill_table;
 
 extern std::vector<skill_table> s_info;
@@ -56,6 +56,7 @@ public:
     static int weapon_exp_level(int weapon_exp);
     static int riding_exp_level(int riding_exp);
     static int spell_exp_level(int spell_exp);
+    static concptr skill_name(PlayerSkillKindType skill);
 
     void gain_melee_weapon_exp(const object_type *o_ptr);
     void gain_range_weapon_exp(const object_type *o_ptr);

diff --git a/src/player/player-status.cpp b/src/player/player-status.cpp
index efcfbd2..f3ba5d2 100644 (file)
--- a/src/player/player-status.cpp
+++ b/src/player/player-status.cpp
@@ -1555,7 +1555,7 @@ static ARMOUR_CLASS calc_base_ac(player_type *player_ptr)
     const auto o_ptr_mh = &player_ptr->inventory_list[INVEN_MAIN_HAND];
     const auto o_ptr_sh = &player_ptr->inventory_list[INVEN_SUB_HAND];
     if (o_ptr_mh->is_armour() || o_ptr_sh->is_armour()) {
-        ac += player_ptr->skill_exp[SKILL_SHIELD] * (1 + player_ptr->lev / 22) / 2000;
+        ac += player_ptr->skill_exp[PlayerSkillKindType::SHIELD] * (1 + player_ptr->lev / 22) / 2000;
     }
 
     return ac;
@@ -1740,7 +1740,7 @@ int16_t calc_double_weapon_penalty(player_type *player_ptr, INVENTORY_IDX slot)
     if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
         auto flags = object_flags(&player_ptr->inventory_list[INVEN_SUB_HAND]);
 
-        penalty = ((100 - player_ptr->skill_exp[SKILL_TWO_WEAPON] / 160) - (130 - player_ptr->inventory_list[slot].weight) / 8);
+        penalty = ((100 - player_ptr->skill_exp[PlayerSkillKindType::TWO_WEAPON] / 160) - (130 - player_ptr->inventory_list[slot].weight) / 8);
         if (((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_QUICKTHORN) && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_TINYTHORN))
             || ((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_ICINGDEATH)
                 && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_TWINKLE))) {
@@ -1802,7 +1802,7 @@ static int16_t calc_riding_bow_penalty(player_type *player_ptr)
         if (player_ptr->tval_ammo != ItemKindType::ARROW)
             penalty = 5;
     } else {
-        penalty = r_info[floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[SKILL_RIDING] / 80;
+        penalty = r_info[floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[PlayerSkillKindType::RIDING] / 80;
         penalty += 30;
         if (penalty < 30)
             penalty = 30;
@@ -2088,7 +2088,7 @@ static short calc_to_hit(player_type *player_ptr, INVENTORY_IDX slot, bool is_re
                 break;
             /* fall through */
         case MELEE_TYPE_BAREHAND_TWO:
-            hit += (player_ptr->skill_exp[SKILL_MARTIAL_ARTS] - PlayerSkill::weapon_exp_at(EXP_LEVEL_BEGINNER)) / 200;
+            hit += (player_ptr->skill_exp[PlayerSkillKindType::MARTIAL_ARTS] - PlayerSkill::weapon_exp_at(EXP_LEVEL_BEGINNER)) / 200;
             break;
 
         default:
@@ -2134,7 +2134,7 @@ static short calc_to_hit(player_type *player_ptr, INVENTORY_IDX slot, bool is_re
                 if ((player_ptr->pclass == PlayerClassType::BEASTMASTER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) {
                     penalty = 5;
                 } else {
-                    penalty = r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[SKILL_RIDING] / 80;
+                    penalty = r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[PlayerSkillKindType::RIDING] / 80;
                     penalty += 30;
                     if (penalty < 30) {
                         penalty = 30;

diff --git a/src/save/player-writer.cpp b/src/save/player-writer.cpp
index a53f005..03ab8fc 100644 (file)
--- a/src/save/player-writer.cpp
+++ b/src/save/player-writer.cpp
@@ -2,6 +2,7 @@
 #include "cmd-building/cmd-building.h"
 #include "dungeon/dungeon.h"
 #include "game-option/birth-options.h"
+#include "player/player-skill.h"
 #include "save/info-writer.h"
 #include "save/player-class-specific-data-writer.h"
 #include "save/save-util.h"

diff --git a/src/spell/spell-info.cpp b/src/spell/spell-info.cpp
index 56ed694..bcd1049 100644 (file)
--- a/src/spell/spell-info.cpp
+++ b/src/spell/spell-info.cpp
@@ -129,7 +129,7 @@ PERCENTAGE spell_chance(player_type *player_ptr, SPELL_IDX spell, int16_t use_re
     chance -= 3 * (player_ptr->lev - s_ptr->slevel);
     chance -= 3 * (adj_mag_stat[player_ptr->stat_index[mp_ptr->spell_stat]] - 1);
     if (player_ptr->riding)
-        chance += (std::max(r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[SKILL_RIDING] / 100 - 10, 0));
+        chance += (std::max(r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[PlayerSkillKindType::RIDING] / 100 - 10, 0));
 
     MANA_POINT need_mana = mod_need_mana(player_ptr, s_ptr->smana, spell, use_realm);
     if (need_mana > player_ptr->csp) {

diff --git a/src/system/player-type-definition.h b/src/system/player-type-definition.h
index 4dec602..f70efad 100644 (file)
--- a/src/system/player-type-definition.h
+++ b/src/system/player-type-definition.h
@@ -15,9 +15,8 @@
 #include <array>
 #include <map>
 
-#include "player/player-skill.h"
-
 enum class ItemKindType : short;
+enum class PlayerSkillKindType;
 enum class RF_ABILITY;
 
 struct floor_type;
@@ -188,7 +187,7 @@ public:
 
     SUB_EXP spell_exp[64]{}; /* Proficiency of spells */
     std::map<ItemKindType, std::array<SUB_EXP, 64>> weapon_exp{}; /* Proficiency of weapons */
-    std::map<skill_idx, SUB_EXP> skill_exp{}; /* Proficiency of misc. skill */
+    std::map<PlayerSkillKindType, SUB_EXP> skill_exp{}; /* Proficiency of misc. skill */
 
     ClassSpecificData class_specific_data;