[Refactor] 再定義したものへ置き換え

diff --git a/src/action/movement-execution.cpp b/src/action/movement-execution.cpp
index 0c87800..12fb537 100644 (file)
--- a/src/action/movement-execution.cpp
+++ b/src/action/movement-execution.cpp
@@ -25,6 +25,7 @@
 #include "monster-race/race-flags2.h"
 #include "monster-race/race-flags7.h"
 #include "monster-race/race-flags8.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-info.h"
 #include "monster/monster-status-setter.h"
@@ -219,7 +220,7 @@ void exe_movement(PlayerType *player_ptr, DIRECTION dir, bool do_pickup, bool br
             energy.reset_player_turn();
             can_move = false;
             disturb(player_ptr, false, true);
-        } else if (f_ptr->flags.has(FloorFeatureType::LAVA) && !(riding_r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK)) {
+        } else if (f_ptr->flags.has(FloorFeatureType::LAVA) && riding_r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_FIRE_MASK)) {
             msg_format(_("%sの上に行けない。", "Too hot to go through."), f_info[g_ptr->get_feat_mimic()].name.c_str());
             energy.reset_player_turn();
             can_move = false;

diff --git a/src/blue-magic/blue-magic-caster.cpp b/src/blue-magic/blue-magic-caster.cpp
index bf6036b..b1e025f 100644 (file)
--- a/src/blue-magic/blue-magic-caster.cpp
+++ b/src/blue-magic/blue-magic-caster.cpp
@@ -99,12 +99,12 @@ static bool exe_blue_teleport_back(PlayerType *player_ptr, GAME_TEXT *m_name)
     m_ptr = &floor_ptr->m_list[floor_ptr->grid_array[target_row][target_col].m_idx];
     r_ptr = &r_info[m_ptr->r_idx];
     monster_desc(player_ptr, m_name, m_ptr, 0);
-    if ((r_ptr->flagsr & RFR_RES_TELE) == 0)
+    if (r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_TELEPORT))
         return false;
 
-    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flagsr & RFR_RES_ALL)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         if (is_original_ap_and_seen(player_ptr, m_ptr))
-            r_ptr->r_flagsr |= RFR_RES_TELE;
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
 
         msg_format(_("%sには効果がなかった！", "%s is unaffected!"), m_name);
         return true;
@@ -114,7 +114,7 @@ static bool exe_blue_teleport_back(PlayerType *player_ptr, GAME_TEXT *m_name)
         return false;
 
     if (is_original_ap_and_seen(player_ptr, m_ptr))
-        r_ptr->r_flagsr |= RFR_RES_TELE;
+        r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
 
     msg_format(_("%sには耐性がある！", "%s resists!"), m_name);
     return true;

diff --git a/src/cmd-action/cmd-mane.cpp b/src/cmd-action/cmd-mane.cpp
index 1a81979..5ae9729 100644 (file)
--- a/src/cmd-action/cmd-mane.cpp
+++ b/src/cmd-action/cmd-mane.cpp
@@ -971,17 +971,17 @@ static bool use_mane(PlayerType *player_ptr, MonsterAbilityType spell)
         m_ptr = &player_ptr->current_floor_ptr->m_list[player_ptr->current_floor_ptr->grid_array[target_row][target_col].m_idx];
         r_ptr = &r_info[m_ptr->r_idx];
         monster_desc(player_ptr, m_name, m_ptr, 0);
-        if (r_ptr->flagsr & RFR_RES_TELE) {
-            if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flagsr & RFR_RES_ALL)) {
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
+            if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
                 if (is_original_ap_and_seen(player_ptr, m_ptr)) {
-                    r_ptr->r_flagsr |= RFR_RES_TELE;
+                    r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
                 }
                 msg_format(_("%sには効果がなかった！", "%s is unaffected!"), m_name);
 
                 break;
             } else if (r_ptr->level > randint1(100)) {
                 if (is_original_ap_and_seen(player_ptr, m_ptr)) {
-                    r_ptr->r_flagsr |= RFR_RES_TELE;
+                    r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
                 }
                 msg_format(_("%sには耐性がある！", "%s resists!"), m_name);
 

diff --git a/src/combat/attack-accuracy.cpp b/src/combat/attack-accuracy.cpp
index 35b9da7..76e01c5 100644 (file)
--- a/src/combat/attack-accuracy.cpp
+++ b/src/combat/attack-accuracy.cpp
@@ -126,7 +126,7 @@ static bool decide_attack_hit(PlayerType *player_ptr, player_attack_type *pa_ptr
             n *= 2;
 
         success_hit = one_in_(n);
-    } else if (PlayerClass(player_ptr).equals(PlayerClassType::NINJA) && ((pa_ptr->backstab || pa_ptr->surprise_attack) && !(r_ptr->flagsr & RFR_RES_ALL)))
+    } else if (PlayerClass(player_ptr).equals(PlayerClassType::NINJA) && ((pa_ptr->backstab || pa_ptr->surprise_attack) && !r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)))
         success_hit = true;
     else
         success_hit = test_hit_norm(player_ptr, chance, r_ptr->ac, pa_ptr->m_ptr->ml);

diff --git a/src/combat/aura-counterattack.cpp b/src/combat/aura-counterattack.cpp
index 05eea7d..8c03d53 100644 (file)
--- a/src/combat/aura-counterattack.cpp
+++ b/src/combat/aura-counterattack.cpp
@@ -14,6 +14,7 @@
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags-resistance.h"
 #include "monster-race/race-flags3.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-damage.h"
 #include "monster/monster-info.h"
 #include "monster/monster-status.h"
@@ -36,9 +37,9 @@ static void aura_fire_by_monster_attack(PlayerType *player_ptr, MonsterAttackPla
         return;
 
     auto *r_ptr = &r_info[monap_ptr->m_ptr->r_idx];
-    if ((r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK) != 0) {
+    if (r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_FIRE_MASK)) {
         if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-            r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK);
+            r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & RFR_EFF_IM_FIRE_MASK);
 
         return;
     }
@@ -59,9 +60,9 @@ static void aura_elec_by_monster_attack(PlayerType *player_ptr, MonsterAttackPla
         return;
 
     auto *r_ptr = &r_info[monap_ptr->m_ptr->r_idx];
-    if ((r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK) != 0) {
+    if (r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_ELEC_MASK)) {
         if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-            r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK);
+            r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & RFR_EFF_IM_ELEC_MASK);
 
         return;
     }
@@ -82,9 +83,9 @@ static void aura_cold_by_monster_attack(PlayerType *player_ptr, MonsterAttackPla
         return;
 
     auto *r_ptr = &r_info[monap_ptr->m_ptr->r_idx];
-    if ((r_ptr->flagsr & RFR_EFF_IM_COLD_MASK) != 0) {
+    if (r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_COLD_MASK)) {
         if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-            r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_COLD_MASK);
+            r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & RFR_EFF_IM_COLD_MASK);
 
         return;
     }
@@ -105,9 +106,9 @@ static void aura_shards_by_monster_attack(PlayerType *player_ptr, MonsterAttackP
         return;
 
     auto *r_ptr = &r_info[monap_ptr->m_ptr->r_idx];
-    if ((r_ptr->flagsr & RFR_EFF_RES_SHAR_MASK) != 0) {
+    if (r_ptr->resistance_flags.has_any_of(RFR_EFF_RESIST_SHARDS_MASK)) {
         if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-            r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_RES_SHAR_MASK);
+            r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & RFR_EFF_RESIST_SHARDS_MASK);
     } else {
         int dam = damroll(2, 6);
         dam = mon_damage_mod(player_ptr, monap_ptr->m_ptr, dam, false);
@@ -132,9 +133,9 @@ static void aura_holy_by_monster_attack(PlayerType *player_ptr, MonsterAttackPla
     if (r_ptr->kind_flags.has_not(MonsterKindType::EVIL))
         return;
 
-    if ((r_ptr->flagsr & RFR_RES_ALL) != 0) {
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-            r_ptr->r_flagsr |= RFR_RES_ALL;
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_ALL);
 
         return;
     }
@@ -158,9 +159,9 @@ static void aura_force_by_monster_attack(PlayerType *player_ptr, MonsterAttackPl
         return;
 
     auto *r_ptr = &r_info[monap_ptr->m_ptr->r_idx];
-    if ((r_ptr->flagsr & RFR_RES_ALL) != 0) {
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-            r_ptr->r_flagsr |= RFR_RES_ALL;
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_ALL);
 
         return;
     }
@@ -183,9 +184,11 @@ static void aura_shadow_by_monster_attack(PlayerType *player_ptr, MonsterAttackP
     int dam = 1;
     ObjectType *o_armed_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND];
     auto *r_ptr = &r_info[monap_ptr->m_ptr->r_idx];
-    if (((r_ptr->flagsr & RFR_RES_ALL) != 0) || ((r_ptr->flagsr & RFR_RES_DARK) != 0)) {
+    const EnumClassFlagGroup<MonsterResistanceType> resist_flags = { MonsterResistanceType::RESIST_ALL, MonsterResistanceType::RESIST_DARK };
+
+    if (r_ptr->resistance_flags.has_any_of(resist_flags)) {
         if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-            r_ptr->r_flagsr |= (RFR_RES_ALL | RFR_RES_DARK);
+            r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & resist_flags);
 
         return;
     }

diff --git a/src/combat/shoot.cpp b/src/combat/shoot.cpp
index 302942e..4525acc 100644 (file)
--- a/src/combat/shoot.cpp
+++ b/src/combat/shoot.cpp
@@ -36,6 +36,7 @@
 #include "monster-race/race-flags3.h"
 #include "monster-race/race-flags7.h"
 #include "monster-race/race-indice-types.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-damage.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-info.h"
@@ -328,9 +329,9 @@ static MULTIPLY calc_shot_damage_with_slay(
 
         if (flags.has(TR_BRAND_ACID)) {
             /* Notice immunity */
-            if (any_bits(race_ptr->flagsr, RFR_EFF_IM_ACID_MASK)) {
+            if (race_ptr->resistance_flags.has_any_of(RFR_EFF_IM_ACID_MASK)) {
                 if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                    set_bits(race_ptr->r_flagsr, (race_ptr->flagsr & RFR_EFF_IM_ACID_MASK));
+                    race_ptr->r_resistance_flags.set(race_ptr->resistance_flags & RFR_EFF_IM_ACID_MASK);
                 }
             } else {
                 if (mult < 17)
@@ -340,9 +341,9 @@ static MULTIPLY calc_shot_damage_with_slay(
 
         if (flags.has(TR_BRAND_ELEC)) {
             /* Notice immunity */
-            if (any_bits(race_ptr->flagsr, RFR_EFF_IM_ELEC_MASK)) {
+            if (race_ptr->resistance_flags.has_any_of(RFR_EFF_IM_ELEC_MASK)) {
                 if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                    set_bits(race_ptr->r_flagsr, (race_ptr->flagsr & RFR_EFF_IM_ELEC_MASK));
+                    race_ptr->r_resistance_flags.set(race_ptr->resistance_flags & RFR_EFF_IM_ELEC_MASK);
                 }
             } else {
                 if (mult < 17)
@@ -352,18 +353,18 @@ static MULTIPLY calc_shot_damage_with_slay(
 
         if (flags.has(TR_BRAND_FIRE)) {
             /* Notice immunity */
-            if (any_bits(race_ptr->flagsr, RFR_EFF_IM_FIRE_MASK)) {
+            if (race_ptr->resistance_flags.has_any_of(RFR_EFF_IM_FIRE_MASK)) {
                 if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                    set_bits(race_ptr->r_flagsr, (race_ptr->flagsr & RFR_EFF_IM_FIRE_MASK));
+                    race_ptr->r_resistance_flags.set(race_ptr->resistance_flags & RFR_EFF_IM_FIRE_MASK);
                 }
             }
             /* Otherwise, take the damage */
             else {
-                if (any_bits(race_ptr->flags3, RF3_HURT_FIRE)) {
+                if (race_ptr->resistance_flags.has(MonsterResistanceType::HURT_FIRE)) {
                     if (mult < 25)
                         mult = 25;
                     if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                        set_bits(race_ptr->r_flags3, RF3_HURT_FIRE);
+                        race_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_FIRE);
                     }
                 } else if (mult < 17)
                     mult = 17;
@@ -372,18 +373,18 @@ static MULTIPLY calc_shot_damage_with_slay(
 
         if (flags.has(TR_BRAND_COLD)) {
             /* Notice immunity */
-            if (any_bits(race_ptr->flagsr, RFR_EFF_IM_COLD_MASK)) {
+            if (race_ptr->resistance_flags.has_any_of(RFR_EFF_IM_COLD_MASK)) {
                 if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                    set_bits(race_ptr->r_flagsr, (race_ptr->flagsr & RFR_EFF_IM_COLD_MASK));
+                    race_ptr->r_resistance_flags.set(race_ptr->resistance_flags & RFR_EFF_IM_COLD_MASK);
                 }
             }
             /* Otherwise, take the damage */
             else {
-                if (any_bits(race_ptr->flags3, RF3_HURT_COLD)) {
+                if (race_ptr->resistance_flags.has(MonsterResistanceType::HURT_COLD)) {
                     if (mult < 25)
                         mult = 25;
                     if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                        set_bits(race_ptr->r_flags3, RF3_HURT_COLD);
+                        race_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_COLD);
                     }
                 } else if (mult < 17)
                     mult = 17;
@@ -392,9 +393,9 @@ static MULTIPLY calc_shot_damage_with_slay(
 
         if (flags.has(TR_BRAND_POIS)) {
             /* Notice immunity */
-            if (any_bits(race_ptr->flagsr, RFR_EFF_IM_POIS_MASK)) {
+            if (race_ptr->resistance_flags.has_any_of(RFR_EFF_IM_POISON_MASK)) {
                 if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                    set_bits(race_ptr->r_flagsr, race_ptr->flagsr & RFR_EFF_IM_POIS_MASK);
+                    race_ptr->r_resistance_flags.set(race_ptr->resistance_flags & RFR_EFF_IM_POISON_MASK);
                 }
             }
             /* Otherwise, take the damage */

diff --git a/src/combat/slaying.cpp b/src/combat/slaying.cpp
index 1de89d9..40228e3 100644 (file)
--- a/src/combat/slaying.cpp
+++ b/src/combat/slaying.cpp
@@ -8,6 +8,7 @@
 #include "monster-race/race-flags2.h"
 #include "monster-race/race-flags3.h"
 #include "monster-race/race-indice-types.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-info.h"
 #include "object-enchant/tr-types.h"
 #include "object/object-flags.h"
@@ -89,14 +90,14 @@ MULTIPLY mult_brand(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs,
 {
     static const struct brand_table_t {
         tr_type brand_flag;
-        BIT_FLAGS resist_mask;
-        BIT_FLAGS hurt_flag;
+        EnumClassFlagGroup<MonsterResistanceType> resist_mask;
+        MonsterResistanceType hurt_flag;
     } brand_table[] = {
-        { TR_BRAND_ACID, RFR_EFF_IM_ACID_MASK, 0U },
-        { TR_BRAND_ELEC, RFR_EFF_IM_ELEC_MASK, 0U },
-        { TR_BRAND_FIRE, RFR_EFF_IM_FIRE_MASK, RF3_HURT_FIRE },
-        { TR_BRAND_COLD, RFR_EFF_IM_COLD_MASK, RF3_HURT_COLD },
-        { TR_BRAND_POIS, RFR_EFF_IM_POIS_MASK, 0U },
+        { TR_BRAND_ACID, RFR_EFF_IM_ACID_MASK, MonsterResistanceType::MAX },
+        { TR_BRAND_ELEC, RFR_EFF_IM_ELEC_MASK, MonsterResistanceType::MAX },
+        { TR_BRAND_FIRE, RFR_EFF_IM_FIRE_MASK, MonsterResistanceType::HURT_FIRE },
+        { TR_BRAND_COLD, RFR_EFF_IM_COLD_MASK, MonsterResistanceType::HURT_COLD },
+        { TR_BRAND_POIS, RFR_EFF_IM_POISON_MASK, MonsterResistanceType::MAX },
     };
 
     auto *r_ptr = &r_info[m_ptr->r_idx];
@@ -107,18 +108,18 @@ MULTIPLY mult_brand(PlayerType *player_ptr, MULTIPLY mult, const TrFlags &flgs,
             continue;
 
         /* Notice immunity */
-        if (r_ptr->flagsr & p->resist_mask) {
+        if (r_ptr->resistance_flags.has_any_of(p->resist_mask)) {
             if (is_original_ap_and_seen(player_ptr, m_ptr)) {
-                r_ptr->r_flagsr |= (r_ptr->flagsr & p->resist_mask);
+                r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & p->resist_mask);
             }
 
             continue;
         }
 
         /* Otherwise, take the damage */
-        if (r_ptr->flags3 & p->hurt_flag) {
+        if (r_ptr->resistance_flags.has(p->hurt_flag)) {
             if (is_original_ap_and_seen(player_ptr, m_ptr)) {
-                r_ptr->r_flags3 |= p->hurt_flag;
+                r_ptr->r_resistance_flags.set(p->hurt_flag);
             }
 
             mult = std::max<short>(mult, 50);

diff --git a/src/effect/effect-monster-evil.cpp b/src/effect/effect-monster-evil.cpp
index 62ac154..ee19611 100644 (file)
--- a/src/effect/effect-monster-evil.cpp
+++ b/src/effect/effect-monster-evil.cpp
@@ -12,19 +12,19 @@
 
 static bool effect_monster_away_resist(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_TELE) == 0)
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_TELEPORT))
         return false;
 
-    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->flagsr & RFR_RES_ALL)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-            em_ptr->r_ptr->r_flagsr |= RFR_RES_TELE;
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         return true;
     }
 
     if (em_ptr->r_ptr->level > randint1(100)) {
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-            em_ptr->r_ptr->r_flagsr |= RFR_RES_TELE;
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
         em_ptr->note = _("には耐性がある！", " resists!");
         return true;
     }

diff --git a/src/effect/effect-monster-lite-dark.cpp b/src/effect/effect-monster-lite-dark.cpp
index 31728eb..835bb6a 100644 (file)
--- a/src/effect/effect-monster-lite-dark.cpp
+++ b/src/effect/effect-monster-lite-dark.cpp
@@ -1,4 +1,4 @@
-#include "effect/effect-monster-lite-dark.h"
+#include "effect/effect-monster-lite-dark.h"
 #include "effect/effect-monster-util.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags-resistance.h"
@@ -15,16 +15,15 @@ process_result effect_monster_lite_weak(PlayerType *player_ptr, effect_monster_t
                return PROCESS_CONTINUE;
        }
 
-       if ((em_ptr->r_ptr->flags3 & RF3_HURT_LITE) == 0)
-       {
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_LITE)) {
+        em_ptr->dam = 0;
+        return PROCESS_CONTINUE;
+    }
 
        if (em_ptr->seen) em_ptr->obvious = true;
 
        if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-               em_ptr->r_ptr->r_flags3 |= (RF3_HURT_LITE);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_LITE);
 
        em_ptr->note = _("は光に身をすくめた！", " cringes from the light!");
        em_ptr->note_dies = _("は光を受けてしぼんでしまった！", " shrivels away in the light!");
@@ -36,22 +35,20 @@ process_result effect_monster_lite(PlayerType *player_ptr, effect_monster_type *
 {
        if (em_ptr->seen) em_ptr->obvious = true;
 
-       if (em_ptr->r_ptr->flagsr & RFR_RES_LITE)
-       {
-               em_ptr->note = _("には耐性がある！", " resists!");
-               em_ptr->dam *= 2; em_ptr->dam /= (randint1(6) + 6);
-               if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-                       em_ptr->r_ptr->r_flagsr |= (RFR_RES_LITE);
-       }
-       else if (em_ptr->r_ptr->flags3 & (RF3_HURT_LITE))
-       {
-               if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-                       em_ptr->r_ptr->r_flags3 |= (RF3_HURT_LITE);
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_LITE)) {
+        em_ptr->note = _("には耐性がある！", " resists!");
+        em_ptr->dam *= 2;
+        em_ptr->dam /= (randint1(6) + 6);
+        if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_LITE);
+    } else if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_LITE)) {
+        if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_LITE);
 
-               em_ptr->note = _("は光に身をすくめた！", " cringes from the light!");
-               em_ptr->note_dies = _("は光を受けてしぼんでしまった！", " shrivels away in the light!");
-               em_ptr->dam *= 2;
-       }
+        em_ptr->note = _("は光に身をすくめた！", " cringes from the light!");
+        em_ptr->note_dies = _("は光を受けてしぼんでしまった！", " shrivels away in the light!");
+        em_ptr->dam *= 2;
+    }
 
        return PROCESS_CONTINUE;
 }
@@ -61,13 +58,13 @@ process_result effect_monster_dark(PlayerType *player_ptr, effect_monster_type *
 {
        if (em_ptr->seen) em_ptr->obvious = true;
 
-       if ((em_ptr->r_ptr->flagsr & RFR_RES_DARK) == 0)
-               return PROCESS_CONTINUE;
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_DARK))
+        return PROCESS_CONTINUE;
 
        em_ptr->note = _("には耐性がある！", " resists!");
        em_ptr->dam *= 2; em_ptr->dam /= (randint1(6) + 6);
        if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-               em_ptr->r_ptr->r_flagsr |= (RFR_RES_DARK);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_DARK);
 
        return PROCESS_CONTINUE;
 }

diff --git a/src/effect/effect-monster-resist-hurt.cpp b/src/effect/effect-monster-resist-hurt.cpp
index 8335b9e..ad01cb4 100644 (file)
--- a/src/effect/effect-monster-resist-hurt.cpp
+++ b/src/effect/effect-monster-resist-hurt.cpp
@@ -36,14 +36,14 @@ process_result effect_monster_acid(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_IM_ACID) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::IMMUNE_ACID)) {
         return PROCESS_CONTINUE;
     }
 
     em_ptr->note = _("にはかなり耐性がある！", " resists a lot.");
     em_ptr->dam /= 9;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_IM_ACID);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_ACID);
     }
 
     return PROCESS_CONTINUE;
@@ -55,14 +55,14 @@ process_result effect_monster_elec(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_IM_ELEC) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::IMMUNE_ELEC)) {
         return PROCESS_CONTINUE;
     }
 
     em_ptr->note = _("にはかなり耐性がある！", " resists a lot.");
     em_ptr->dam /= 9;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_IM_ELEC);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_ELEC);
     }
 
     return PROCESS_CONTINUE;
@@ -74,24 +74,24 @@ process_result effect_monster_fire(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if (em_ptr->r_ptr->flagsr & RFR_IM_FIRE) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_FIRE)) {
         em_ptr->note = _("にはかなり耐性がある！", " resists a lot.");
         em_ptr->dam /= 9;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_IM_FIRE);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_FIRE);
         }
 
         return PROCESS_CONTINUE;
     }
 
-    if ((em_ptr->r_ptr->flags3 & (RF3_HURT_FIRE)) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_FIRE)) {
         return PROCESS_CONTINUE;
     }
 
     em_ptr->note = _("はひどい痛手をうけた。", " is hit hard.");
     em_ptr->dam *= 2;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flags3 |= (RF3_HURT_FIRE);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_FIRE);
     }
 
     return PROCESS_CONTINUE;
@@ -103,24 +103,24 @@ process_result effect_monster_cold(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if (em_ptr->r_ptr->flagsr & RFR_IM_COLD) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_COLD)) {
         em_ptr->note = _("にはかなり耐性がある！", " resists a lot.");
         em_ptr->dam /= 9;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_IM_COLD);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_COLD);
         }
 
         return PROCESS_CONTINUE;
     }
 
-    if ((em_ptr->r_ptr->flags3 & (RF3_HURT_COLD)) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_COLD)) {
         return PROCESS_CONTINUE;
     }
 
     em_ptr->note = _("はひどい痛手をうけた。", " is hit hard.");
     em_ptr->dam *= 2;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flags3 |= (RF3_HURT_COLD);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_COLD);
     }
 
     return PROCESS_CONTINUE;
@@ -132,14 +132,14 @@ process_result effect_monster_pois(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_IM_POIS) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::IMMUNE_POISON)) {
         return PROCESS_CONTINUE;
     }
 
     em_ptr->note = _("にはかなり耐性がある！", " resists a lot.");
     em_ptr->dam /= 9;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_IM_POIS);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_POISON);
     }
 
     return PROCESS_CONTINUE;
@@ -151,12 +151,12 @@ process_result effect_monster_nuke(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if (em_ptr->r_ptr->flagsr & RFR_IM_POIS) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_POISON)) {
         em_ptr->note = _("には耐性がある。", " resists.");
         em_ptr->dam *= 3;
         em_ptr->dam /= randint1(6) + 6;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_IM_POIS);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_POISON);
         }
 
         return PROCESS_CONTINUE;
@@ -225,7 +225,7 @@ process_result effect_monster_plasma(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_PLAS) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_PLASMA)) {
         return PROCESS_CONTINUE;
     }
 
@@ -233,7 +233,7 @@ process_result effect_monster_plasma(PlayerType *player_ptr, effect_monster_type
     em_ptr->dam *= 3;
     em_ptr->dam /= randint1(6) + 6;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_PLAS);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_PLASMA);
     }
 
     return PROCESS_CONTINUE;
@@ -241,7 +241,7 @@ process_result effect_monster_plasma(PlayerType *player_ptr, effect_monster_type
 
 static bool effect_monster_nether_resist(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_NETH) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_NETHER)) {
         return false;
     }
 
@@ -258,7 +258,7 @@ static bool effect_monster_nether_resist(PlayerType *player_ptr, effect_monster_
     }
 
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_NETH);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_NETHER);
     }
 
     return true;
@@ -289,7 +289,7 @@ process_result effect_monster_water(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_WATE) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_WATER)) {
         return PROCESS_CONTINUE;
     }
 
@@ -303,7 +303,7 @@ process_result effect_monster_water(PlayerType *player_ptr, effect_monster_type
     }
 
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_WATE);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_WATER);
     }
 
     return PROCESS_CONTINUE;
@@ -315,12 +315,12 @@ process_result effect_monster_chaos(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if (em_ptr->r_ptr->flagsr & RFR_RES_CHAO) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_CHAOS)) {
         em_ptr->note = _("には耐性がある。", " resists.");
         em_ptr->dam *= 3;
         em_ptr->dam /= randint1(6) + 6;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_RES_CHAO);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_CHAOS);
         }
     } else if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::DEMON) && one_in_(3)) {
         em_ptr->note = _("はいくらか耐性を示した。", " resists somewhat.");
@@ -343,7 +343,7 @@ process_result effect_monster_shards(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_SHAR) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_SHARDS)) {
         return PROCESS_CONTINUE;
     }
 
@@ -351,7 +351,7 @@ process_result effect_monster_shards(PlayerType *player_ptr, effect_monster_type
     em_ptr->dam *= 3;
     em_ptr->dam /= randint1(6) + 6;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_SHAR);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_SHARDS);
     }
 
     return PROCESS_CONTINUE;
@@ -363,14 +363,14 @@ process_result effect_monster_rocket(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_SHAR) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_SHARDS)) {
         return PROCESS_CONTINUE;
     }
 
     em_ptr->note = _("はいくらか耐性を示した。", " resists somewhat.");
     em_ptr->dam /= 2;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_SHAR);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_SHARDS);
     }
 
     return PROCESS_CONTINUE;
@@ -382,7 +382,7 @@ process_result effect_monster_sound(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_SOUN) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_SOUND)) {
         em_ptr->do_stun = (10 + randint1(15) + em_ptr->r) / (em_ptr->r + 1);
         return PROCESS_CONTINUE;
     }
@@ -391,7 +391,7 @@ process_result effect_monster_sound(PlayerType *player_ptr, effect_monster_type
     em_ptr->dam *= 2;
     em_ptr->dam /= randint1(6) + 6;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_SOUN);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_SOUND);
     }
 
     return PROCESS_CONTINUE;
@@ -424,7 +424,7 @@ process_result effect_monster_disenchant(PlayerType *player_ptr, effect_monster_
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_DISE) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_DISENCHANT)) {
         return PROCESS_CONTINUE;
     }
 
@@ -432,7 +432,7 @@ process_result effect_monster_disenchant(PlayerType *player_ptr, effect_monster_
     em_ptr->dam *= 3;
     em_ptr->dam /= randint1(6) + 6;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_DISE);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_DISENCHANT);
     }
 
     return PROCESS_CONTINUE;
@@ -444,7 +444,7 @@ process_result effect_monster_nexus(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_NEXU) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_NEXUS)) {
         return PROCESS_CONTINUE;
     }
 
@@ -452,7 +452,7 @@ process_result effect_monster_nexus(PlayerType *player_ptr, effect_monster_type
     em_ptr->dam *= 3;
     em_ptr->dam /= randint1(6) + 6;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_NEXU);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_NEXUS);
     }
 
     return PROCESS_CONTINUE;
@@ -464,7 +464,7 @@ process_result effect_monster_force(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_WALL) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_FORCE)) {
         em_ptr->do_stun = (randint1(15) + em_ptr->r) / (em_ptr->r + 1);
         return PROCESS_CONTINUE;
     }
@@ -473,7 +473,7 @@ process_result effect_monster_force(PlayerType *player_ptr, effect_monster_type
     em_ptr->dam *= 3;
     em_ptr->dam /= randint1(6) + 6;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_WALL);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_FORCE);
     }
 
     return PROCESS_CONTINUE;
@@ -486,12 +486,12 @@ process_result effect_monster_inertial(PlayerType *player_ptr, effect_monster_ty
         em_ptr->obvious = true;
     }
 
-    if (em_ptr->r_ptr->flagsr & RFR_RES_INER) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_INERTIA)) {
         em_ptr->note = _("には耐性がある。", " resists.");
         em_ptr->dam *= 3;
         em_ptr->dam /= randint1(6) + 6;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_RES_INER);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_INERTIA);
         }
 
         return PROCESS_CONTINUE;
@@ -517,7 +517,7 @@ process_result effect_monster_time(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_TIME) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_TIME)) {
         em_ptr->do_time = (em_ptr->dam + 1) / 2;
         return PROCESS_CONTINUE;
     }
@@ -526,7 +526,7 @@ process_result effect_monster_time(PlayerType *player_ptr, effect_monster_type *
     em_ptr->dam *= 3;
     em_ptr->dam /= randint1(6) + 6;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_TIME);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TIME);
     }
 
     return PROCESS_CONTINUE;
@@ -538,13 +538,13 @@ static bool effect_monster_gravity_resist_teleport(PlayerType *player_ptr, effec
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flagsr & RFR_RES_TELE) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_TELEPORT)) {
         return false;
     }
 
     if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= RFR_RES_TELE;
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
         }
 
         em_ptr->note = _("には効果がなかった。", " is unaffected!");
@@ -556,7 +556,7 @@ static bool effect_monster_gravity_resist_teleport(PlayerType *player_ptr, effec
     }
 
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flagsr |= RFR_RES_TELE;
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
     }
 
     em_ptr->note = _("には耐性がある！", " resists!");
@@ -600,13 +600,13 @@ process_result effect_monster_gravity(PlayerType *player_ptr, effect_monster_typ
         em_ptr->do_dist = 0;
     }
 
-    if (em_ptr->r_ptr->flagsr & RFR_RES_GRAV) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_GRAVITY)) {
         em_ptr->note = _("には耐性がある！", " resists!");
         em_ptr->dam *= 3;
         em_ptr->dam /= randint1(6) + 6;
         em_ptr->do_dist = 0;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_RES_GRAV);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_GRAVITY);
         }
 
         return PROCESS_CONTINUE;
@@ -623,12 +623,12 @@ process_result effect_monster_disintegration(PlayerType *player_ptr, effect_mons
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flags3 & RF3_HURT_ROCK) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_ROCK)) {
         return PROCESS_CONTINUE;
     }
 
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        em_ptr->r_ptr->r_flags3 |= (RF3_HURT_ROCK);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_ROCK);
     }
 
     em_ptr->note = _("の皮膚がただれた！", " loses some skin!");
@@ -644,17 +644,17 @@ process_result effect_monster_icee_bolt(PlayerType *player_ptr, effect_monster_t
     }
 
     em_ptr->do_stun = (randint1(15) + 1) / (em_ptr->r + 1);
-    if (em_ptr->r_ptr->flagsr & RFR_IM_COLD) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_COLD)) {
         em_ptr->note = _("にはかなり耐性がある！", " resists a lot.");
         em_ptr->dam /= 9;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_IM_COLD);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_COLD);
         }
-    } else if (em_ptr->r_ptr->flags3 & (RF3_HURT_COLD)) {
+    } else if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_COLD)) {
         em_ptr->note = _("はひどい痛手をうけた。", " is hit hard.");
         em_ptr->dam *= 2;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flags3 |= (RF3_HURT_COLD);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_COLD);
         }
     }
 
@@ -690,19 +690,19 @@ process_result effect_monster_void(PlayerType *player_ptr, effect_monster_type *
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
             set_bits(em_ptr->r_ptr->r_flags2, RF2_PASS_WALL);
         }
-    } else if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_TELE | RFR_RES_WALL | RFR_RES_GRAV)) {
+    } else if (em_ptr->r_ptr->resistance_flags.has_any_of({ MonsterResistanceType::RESIST_TELEPORT, MonsterResistanceType::RESIST_FORCE, MonsterResistanceType::RESIST_GRAVITY })) {
         em_ptr->note = _("には耐性がある！", " resists!");
         em_ptr->dam *= 3;
         em_ptr->dam /= randint1(6) + 6;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_TELE)) {
-                set_bits(em_ptr->r_ptr->r_flagsr, RFR_RES_TELE);
+            if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
+                em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
             }
-            if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_WALL)) {
-                set_bits(em_ptr->r_ptr->r_flagsr, RFR_RES_WALL);
+            if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_FORCE)) {
+                em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_FORCE);
             }
-            if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_GRAV)) {
-                set_bits(em_ptr->r_ptr->r_flagsr, RFR_RES_GRAV);
+            if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_GRAVITY)) {
+                em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_GRAVITY);
             }
         }
     } else {
@@ -733,19 +733,19 @@ process_result effect_monster_abyss(PlayerType *player_ptr, effect_monster_type
         em_ptr->note = _("には耐性がある！", " resists!");
         em_ptr->dam *= 3;
         em_ptr->dam /= (randint1(6) + 6);
-    } else if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_DARK)) {
+    } else if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_DARK)) {
         em_ptr->note = _("には耐性がある！", " resists!");
         em_ptr->dam *= 3;
         em_ptr->dam /= (randint1(4) + 5);
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            em_ptr->r_ptr->r_flagsr |= (RFR_RES_DARK);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_DARK);
         }
     } else if (!any_bits(em_ptr->r_ptr->flags7, RF7_CAN_FLY)) {
-        if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_TELE)) {
+        if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
             em_ptr->dam *= 5;
             em_ptr->dam /= 4;
             if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-                set_bits(em_ptr->r_ptr->r_flagsr, RFR_RES_TELE);
+                em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
             }
         }
 

diff --git a/src/effect/effect-monster-switcher.cpp b/src/effect/effect-monster-switcher.cpp
index 27a7cea..4f71b80 100644 (file)
--- a/src/effect/effect-monster-switcher.cpp
+++ b/src/effect/effect-monster-switcher.cpp
@@ -100,7 +100,7 @@ process_result effect_monster_death_ray(PlayerType *player_ptr, effect_monster_t
 
 process_result effect_monster_kill_wall(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if ((em_ptr->r_ptr->flags3 & (RF3_HURT_ROCK)) == 0) {
+    if (em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_ROCK)) {
         em_ptr->dam = 0;
         return PROCESS_CONTINUE;
     }
@@ -109,7 +109,7 @@ process_result effect_monster_kill_wall(PlayerType *player_ptr, effect_monster_t
         em_ptr->obvious = true;
 
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-        em_ptr->r_ptr->r_flags3 |= (RF3_HURT_ROCK);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_ROCK);
 
     em_ptr->note = _("の皮膚がただれた！", " loses some skin!");
     em_ptr->note_dies = _("はドロドロに溶けた！", " dissolves!");
@@ -262,12 +262,12 @@ process_result effect_monster_photo(PlayerType *player_ptr, effect_monster_type
     if (!em_ptr->who)
         msg_format(_("%sを写真に撮った。", "You take a photograph of %s."), em_ptr->m_name);
 
-    if (em_ptr->r_ptr->flags3 & (RF3_HURT_LITE)) {
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_LITE)) {
         if (em_ptr->seen)
             em_ptr->obvious = true;
 
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-            em_ptr->r_ptr->r_flags3 |= (RF3_HURT_LITE);
+            em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_LITE);
 
         em_ptr->note = _("は光に身をすくめた！", " cringes from the light!");
         em_ptr->note_dies = _("は光を受けてしぼんでしまった！", " shrivels away in the light!");

diff --git a/src/effect/effect-monster.cpp b/src/effect/effect-monster.cpp
index 4c40512..c289e15 100644 (file)
--- a/src/effect/effect-monster.cpp
+++ b/src/effect/effect-monster.cpp
@@ -30,6 +30,7 @@
 #include "monster-race/race-flags3.h"
 #include "monster-race/race-flags7.h"
 #include "monster-race/race-indice-types.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-damage.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-description-types.h"
@@ -137,7 +138,7 @@ static process_result exe_affect_monster_by_effect(PlayerType *player_ptr, effec
         return result;
     }
 
-    bool do_effect = none_bits(em_ptr->r_ptr->flagsr, RFR_RES_ALL);
+    bool do_effect = em_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_ALL);
     do_effect |= std::any_of(effect_arrtibute.cbegin(), effect_arrtibute.cend(), check);
 
     if (do_effect)
@@ -147,13 +148,13 @@ static process_result exe_affect_monster_by_effect(PlayerType *player_ptr, effec
     ignore_res_all |= (em_ptr->attribute == AttributeType::MONSTER_MELEE);
     ignore_res_all |= (em_ptr->attribute == AttributeType::MONSTER_SHOOT);
 
-    if (any_bits(em_ptr->r_ptr->flagsr, RFR_RES_ALL) && ignore_res_all)
+    if (em_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL) && ignore_res_all)
         return switch_effects_monster(player_ptr, em_ptr);
 
     em_ptr->note = _("には完全な耐性がある！", " is immune.");
     em_ptr->dam = 0;
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-        em_ptr->r_ptr->r_flagsr |= (RFR_RES_ALL);
+        em_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_ALL);
 
     if (em_ptr->attribute == AttributeType::LITE_WEAK || em_ptr->attribute == AttributeType::KILL_WALL)
         em_ptr->skipped = true;
@@ -358,7 +359,7 @@ static void affected_monster_prevents_bad_status(PlayerType *player_ptr, effect_
  */
 static void effect_damage_piles_stun(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if ((em_ptr->do_stun == 0) || (em_ptr->r_ptr->flagsr & (RFR_RES_SOUN | RFR_RES_WALL)) || (em_ptr->r_ptr->flags3 & RF3_NO_STUN))
+    if ((em_ptr->do_stun == 0) || em_ptr->r_ptr->resistance_flags.has_any_of({ MonsterResistanceType::RESIST_SOUND, MonsterResistanceType::RESIST_FORCE }) || (em_ptr->r_ptr->flags3 & RF3_NO_STUN))
         return;
 
     if (em_ptr->seen)
@@ -385,7 +386,7 @@ static void effect_damage_piles_stun(PlayerType *player_ptr, effect_monster_type
  */
 static void effect_damage_piles_confusion(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if ((em_ptr->do_conf == 0) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF) || (em_ptr->r_ptr->flagsr & RFR_EFF_RES_CHAO_MASK))
+    if ((em_ptr->do_conf == 0) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF) || em_ptr->r_ptr->resistance_flags.has_any_of(RFR_EFF_RESIST_CHAOS_MASK))
         return;
 
     if (em_ptr->seen)

diff --git a/src/load/old/load-v1-5-0.cpp b/src/load/old/load-v1-5-0.cpp
index 8984ecb..6f151b2 100644 (file)
--- a/src/load/old/load-v1-5-0.cpp
+++ b/src/load/old/load-v1-5-0.cpp
@@ -459,18 +459,18 @@ void rd_monster_old(PlayerType *player_ptr, monster_type *m_ptr)
     strip_bytes(1);
 }
 
-static void move_RF3_to_RFR(monster_race *r_ptr, const BIT_FLAGS rf3, const BIT_FLAGS rfr)
+static void move_RF3_to_RFR(monster_race *r_ptr, const BIT_FLAGS rf3, const MonsterResistanceType rfr)
 {
     if (r_ptr->r_flags3 & rf3) {
         r_ptr->r_flags3 &= ~rf3;
-        r_ptr->r_flagsr |= rfr;
+        r_ptr->resistance_flags.set(rfr);
     }
 }
 
-static void move_RF4_BR_to_RFR(monster_race *r_ptr, BIT_FLAGS f4, const BIT_FLAGS rf4_br, const BIT_FLAGS rfr)
+static void move_RF4_BR_to_RFR(monster_race *r_ptr, BIT_FLAGS f4, const BIT_FLAGS rf4_br, const MonsterResistanceType rfr)
 {
     if (f4 & rf4_br)
-        r_ptr->r_flagsr |= rfr;
+        r_ptr->resistance_flags.set(rfr);
 }
 
 /*!
@@ -481,38 +481,38 @@ static void move_RF4_BR_to_RFR(monster_race *r_ptr, BIT_FLAGS f4, const BIT_FLAG
  */
 void set_old_lore(monster_race *r_ptr, BIT_FLAGS f4, const MONRACE_IDX r_idx)
 {
-    r_ptr->r_flagsr = 0L;
-    move_RF3_to_RFR(r_ptr, RF3_IM_ACID, RFR_IM_ACID);
-    move_RF3_to_RFR(r_ptr, RF3_IM_ELEC, RFR_IM_ELEC);
-    move_RF3_to_RFR(r_ptr, RF3_IM_FIRE, RFR_IM_FIRE);
-    move_RF3_to_RFR(r_ptr, RF3_IM_COLD, RFR_IM_COLD);
-    move_RF3_to_RFR(r_ptr, RF3_IM_POIS, RFR_IM_POIS);
-    move_RF3_to_RFR(r_ptr, RF3_RES_TELE, RFR_RES_TELE);
-    move_RF3_to_RFR(r_ptr, RF3_RES_NETH, RFR_RES_NETH);
-    move_RF3_to_RFR(r_ptr, RF3_RES_WATE, RFR_RES_WATE);
-    move_RF3_to_RFR(r_ptr, RF3_RES_PLAS, RFR_RES_PLAS);
-    move_RF3_to_RFR(r_ptr, RF3_RES_NEXU, RFR_RES_NEXU);
-    move_RF3_to_RFR(r_ptr, RF3_RES_DISE, RFR_RES_DISE);
-    move_RF3_to_RFR(r_ptr, RF3_RES_ALL, RFR_RES_ALL);
-
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_LITE, RFR_RES_LITE);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_DARK, RFR_RES_DARK);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_SOUN, RFR_RES_SOUN);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_CHAO, RFR_RES_CHAO);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_TIME, RFR_RES_TIME);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_INER, RFR_RES_INER);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_GRAV, RFR_RES_GRAV);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_SHAR, RFR_RES_SHAR);
-    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_WALL, RFR_RES_WALL);
+    r_ptr->r_resistance_flags.clear();
+    move_RF3_to_RFR(r_ptr, RF3_IM_ACID, MonsterResistanceType::IMMUNE_ACID);
+    move_RF3_to_RFR(r_ptr, RF3_IM_ELEC, MonsterResistanceType::IMMUNE_ELEC);
+    move_RF3_to_RFR(r_ptr, RF3_IM_FIRE, MonsterResistanceType::IMMUNE_FIRE);
+    move_RF3_to_RFR(r_ptr, RF3_IM_COLD, MonsterResistanceType::IMMUNE_COLD);
+    move_RF3_to_RFR(r_ptr, RF3_IM_POIS, MonsterResistanceType::IMMUNE_POISON);
+    move_RF3_to_RFR(r_ptr, RF3_RES_TELE, MonsterResistanceType::RESIST_TELEPORT);
+    move_RF3_to_RFR(r_ptr, RF3_RES_NETH, MonsterResistanceType::RESIST_NETHER);
+    move_RF3_to_RFR(r_ptr, RF3_RES_WATE, MonsterResistanceType::RESIST_WATER);
+    move_RF3_to_RFR(r_ptr, RF3_RES_PLAS, MonsterResistanceType::RESIST_PLASMA);
+    move_RF3_to_RFR(r_ptr, RF3_RES_NEXU, MonsterResistanceType::RESIST_NEXUS);
+    move_RF3_to_RFR(r_ptr, RF3_RES_DISE, MonsterResistanceType::RESIST_DISENCHANT);
+    move_RF3_to_RFR(r_ptr, RF3_RES_ALL, MonsterResistanceType::RESIST_ALL);
+
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_LITE, MonsterResistanceType::RESIST_LITE);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_DARK, MonsterResistanceType::RESIST_DARK);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_SOUN, MonsterResistanceType::RESIST_SOUND);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_CHAO, MonsterResistanceType::RESIST_CHAOS);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_TIME, MonsterResistanceType::RESIST_TIME);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_INER, MonsterResistanceType::RESIST_INERTIA);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_GRAV, MonsterResistanceType::RESIST_GRAVITY);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_SHAR, MonsterResistanceType::RESIST_SHARDS);
+    move_RF4_BR_to_RFR(r_ptr, f4, RF4_BR_WALL, MonsterResistanceType::RESIST_FORCE);
 
     if (f4 & RF4_BR_CONF)
         r_ptr->r_flags3 |= RF3_NO_CONF;
 
     if (r_idx == MON_STORMBRINGER)
-        r_ptr->r_flagsr |= RFR_RES_CHAO;
+        r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_CHAOS);
 
     if (r_ptr->r_kind_flags.has(MonsterKindType::ORC))
-        r_ptr->r_flagsr |= RFR_RES_DARK;
+        r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_DARK);
 }
 
 /*!

diff --git a/src/lore/lore-calculator.cpp b/src/lore/lore-calculator.cpp
index b04f1a2..2094abf 100644 (file)
--- a/src/lore/lore-calculator.cpp
+++ b/src/lore/lore-calculator.cpp
@@ -149,5 +149,5 @@ void set_drop_flags(lore_type *lore_ptr)
     lore_ptr->ability_flags = lore_ptr->r_ptr->ability_flags;
     lore_ptr->aura_flags = lore_ptr->r_ptr->aura_flags;
     lore_ptr->behavior_flags = lore_ptr->r_ptr->behavior_flags;
-    lore_ptr->flagsr = lore_ptr->r_ptr->flagsr;
+    lore_ptr->resistance_flags = lore_ptr->r_ptr->resistance_flags;
 }

diff --git a/src/lore/lore-store.cpp b/src/lore/lore-store.cpp
index e79fff6..0be12a2 100644 (file)
--- a/src/lore/lore-store.cpp
+++ b/src/lore/lore-store.cpp
@@ -64,10 +64,11 @@ int lore_do_probe(PlayerType *player_ptr, MONRACE_IDX r_idx)
             n++;
         if (!(r_ptr->r_flags3 & (1UL << i)) && (r_ptr->flags3 & (1UL << i)))
             n++;
-        if (!(r_ptr->r_flagsr & (1UL << i)) && (r_ptr->flagsr & (1UL << i)))
-            n++;
     }
 
+    auto resistance_flags = r_ptr->resistance_flags;
+    n += resistance_flags.reset(r_ptr->r_resistance_flags).count();
+
     auto ability_flags = r_ptr->ability_flags;
     n += ability_flags.reset(r_ptr->r_ability_flags).count();
 
@@ -77,7 +78,7 @@ int lore_do_probe(PlayerType *player_ptr, MONRACE_IDX r_idx)
     r_ptr->r_flags1 = r_ptr->flags1;
     r_ptr->r_flags2 = r_ptr->flags2;
     r_ptr->r_flags3 = r_ptr->flags3;
-    r_ptr->r_flagsr = r_ptr->flagsr;
+    r_ptr->r_resistance_flags = r_ptr->resistance_flags;
     r_ptr->r_ability_flags = r_ptr->ability_flags;
     r_ptr->r_behavior_flags = r_ptr->behavior_flags;
 

diff --git a/src/lore/lore-util.cpp b/src/lore/lore-util.cpp
index 07f4543..a2be20c 100644 (file)
--- a/src/lore/lore-util.cpp
+++ b/src/lore/lore-util.cpp
@@ -48,7 +48,7 @@ lore_type *initialize_lore_type(lore_type *lore_ptr, MONRACE_IDX r_idx, monster_
     lore_ptr->aura_flags = (lore_ptr->r_ptr->aura_flags & lore_ptr->r_ptr->r_aura_flags);
     lore_ptr->behavior_flags = (lore_ptr->r_ptr->behavior_flags & lore_ptr->r_ptr->r_behavior_flags);
     lore_ptr->flags7 = (lore_ptr->r_ptr->flags7 & lore_ptr->r_ptr->flags7);
-    lore_ptr->flagsr = (lore_ptr->r_ptr->flagsr & lore_ptr->r_ptr->r_flagsr);
+    lore_ptr->resistance_flags = (lore_ptr->r_ptr->resistance_flags & lore_ptr->r_ptr->r_resistance_flags);
     lore_ptr->reinforce = false;
     lore_ptr->know_everything = false;
     lore_ptr->mode = mode;

diff --git a/src/lore/magic-types-setter.cpp b/src/lore/magic-types-setter.cpp
index 55773e6..7a0d805 100644 (file)
--- a/src/lore/magic-types-setter.cpp
+++ b/src/lore/magic-types-setter.cpp
@@ -462,7 +462,7 @@ void set_teleport_types(lore_type *lore_ptr)
 void set_floor_types(PlayerType *player_ptr, lore_type *lore_ptr)
 {
     if (lore_ptr->ability_flags.has(MonsterAbilityType::DARKNESS)) {
-        if (!PlayerClass(player_ptr).equals(PlayerClassType::NINJA) || lore_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) || any_bits(lore_ptr->r_ptr->flags3, RF3_HURT_LITE) || (lore_ptr->r_ptr->flags7 & RF7_DARK_MASK)) {
+        if (!PlayerClass(player_ptr).equals(PlayerClassType::NINJA) || lore_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) || lore_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_LITE) || (lore_ptr->r_ptr->flags7 & RF7_DARK_MASK)) {
             lore_ptr->vp[lore_ptr->vn] = _("暗闇", "create darkness");
             lore_ptr->color[lore_ptr->vn++] = TERM_L_DARK;
         } else {

diff --git a/src/melee/melee-postprocess.cpp b/src/melee/melee-postprocess.cpp
index 4dbc132..88be79f 100644 (file)
--- a/src/melee/melee-postprocess.cpp
+++ b/src/melee/melee-postprocess.cpp
@@ -110,7 +110,7 @@ static bool process_invulnerability(mam_pp_type *mam_pp_ptr)
 static bool process_all_resistances(mam_pp_type *mam_pp_ptr)
 {
     auto *r_ptr = &r_info[mam_pp_ptr->m_ptr->r_idx];
-    if ((r_ptr->flagsr & RFR_RES_ALL) == 0)
+    if (r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_ALL))
         return false;
 
     if (mam_pp_ptr->dam > 0) {

diff --git a/src/melee/melee-spell-flags-checker.cpp b/src/melee/melee-spell-flags-checker.cpp
index 832da0b..29ac009 100644 (file)
--- a/src/melee/melee-spell-flags-checker.cpp
+++ b/src/melee/melee-spell-flags-checker.cpp
@@ -100,7 +100,7 @@ static void check_darkness(PlayerType *player_ptr, melee_spell_type *ms_ptr)
         return;
 
     bool vs_ninja = PlayerClass(player_ptr).equals(PlayerClassType::NINJA) && !is_hostile(ms_ptr->t_ptr);
-    bool can_use_lite_area = vs_ninja && ms_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) && none_bits(ms_ptr->r_ptr->flags3, RF3_HURT_LITE) && !(ms_ptr->r_ptr->flags7 & RF7_DARK_MASK);
+    bool can_use_lite_area = vs_ninja && ms_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) && ms_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_LITE) && !(ms_ptr->r_ptr->flags7 & RF7_DARK_MASK);
     if (ms_ptr->r_ptr->behavior_flags.has(MonsterBehaviorType::STUPID))
         return;
 

diff --git a/src/melee/monster-attack-monster.cpp b/src/melee/monster-attack-monster.cpp
index 255389e..f0c0882 100644 (file)
--- a/src/melee/monster-attack-monster.cpp
+++ b/src/melee/monster-attack-monster.cpp
@@ -83,8 +83,8 @@ static void aura_fire_by_melee(PlayerType *player_ptr, mam_type *mam_ptr)
     if (tr_ptr->aura_flags.has_not(MonsterAuraType::FIRE) || (mam_ptr->m_ptr->r_idx == 0))
         return;
 
-    if (((r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK) != 0) && is_original_ap_and_seen(player_ptr, mam_ptr->m_ptr)) {
-        r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK);
+    if (r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_FIRE_MASK) && is_original_ap_and_seen(player_ptr, mam_ptr->m_ptr)) {
+        r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & RFR_EFF_IM_FIRE_MASK);
         return;
     }
 
@@ -105,8 +105,8 @@ static void aura_cold_by_melee(PlayerType *player_ptr, mam_type *mam_ptr)
     if (tr_ptr->aura_flags.has_not(MonsterAuraType::COLD) || (mam_ptr->m_ptr->r_idx == 0))
         return;
 
-    if (((r_ptr->flagsr & RFR_EFF_IM_COLD_MASK) != 0) && is_original_ap_and_seen(player_ptr, mam_ptr->m_ptr)) {
-        r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_COLD_MASK);
+    if (r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_COLD_MASK) && is_original_ap_and_seen(player_ptr, mam_ptr->m_ptr)) {
+        r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & RFR_EFF_IM_COLD_MASK);
         return;
     }
 
@@ -127,8 +127,8 @@ static void aura_elec_by_melee(PlayerType *player_ptr, mam_type *mam_ptr)
     if (tr_ptr->aura_flags.has_not(MonsterAuraType::ELEC) || (mam_ptr->m_ptr->r_idx == 0))
         return;
 
-    if (((r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK) != 0) && is_original_ap_and_seen(player_ptr, mam_ptr->m_ptr)) {
-        r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK);
+    if (r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_ELEC_MASK) && is_original_ap_and_seen(player_ptr, mam_ptr->m_ptr)) {
+        r_ptr->r_resistance_flags.set(r_ptr->resistance_flags & RFR_EFF_IM_ELEC_MASK);
         return;
     }
 

diff --git a/src/mind/mind-elementalist.cpp b/src/mind/mind-elementalist.cpp
index e1c3e7f..a9c37f3 100644 (file)
--- a/src/mind/mind-elementalist.cpp
+++ b/src/mind/mind-elementalist.cpp
@@ -976,23 +976,23 @@ bool is_elemental_genocide_effective(monster_race *r_ptr, AttributeType type)
 {
     switch (type) {
     case AttributeType::FIRE:
-        if (any_bits(r_ptr->flagsr, RFR_IM_FIRE))
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_FIRE))
             return false;
         break;
     case AttributeType::COLD:
-        if (any_bits(r_ptr->flagsr, RFR_IM_COLD))
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_COLD))
             return false;
         break;
     case AttributeType::ELEC:
-        if (any_bits(r_ptr->flagsr, RFR_IM_ELEC))
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_ELEC))
             return false;
         break;
     case AttributeType::ACID:
-        if (any_bits(r_ptr->flagsr, RFR_IM_ACID))
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_ACID))
             return false;
         break;
     case AttributeType::DARK:
-        if (any_bits(r_ptr->flagsr, RFR_RES_DARK) || any_bits(r_ptr->r_flags3, RF3_HURT_LITE))
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_DARK) || r_ptr->r_resistance_flags.has(MonsterResistanceType::HURT_LITE))
             return false;
         break;
     case AttributeType::CONFUSION:
@@ -1000,11 +1000,11 @@ bool is_elemental_genocide_effective(monster_race *r_ptr, AttributeType type)
             return false;
         break;
     case AttributeType::SHARDS:
-        if (any_bits(r_ptr->flagsr, RFR_RES_SHAR))
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_SHARDS))
             return false;
         break;
     case AttributeType::POIS:
-        if (any_bits(r_ptr->flagsr, RFR_IM_POIS))
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_POISON))
             return false;
         break;
     default:

diff --git a/src/mind/mind-ninja.cpp b/src/mind/mind-ninja.cpp
index c6da490..cbe0fef 100644 (file)
--- a/src/mind/mind-ninja.cpp
+++ b/src/mind/mind-ninja.cpp
@@ -4,6 +4,7 @@
 #include "combat/combat-options-type.h"
 #include "core/disturbance.h"
 #include "core/player-redraw-types.h"
+#include "effect/attribute-types.h"
 #include "effect/effect-characteristics.h"
 #include "effect/effect-processor.h"
 #include "effect/spells-effect-util.h"
@@ -42,7 +43,6 @@
 #include "spell-kind/spells-lite.h"
 #include "spell-kind/spells-perception.h"
 #include "spell-kind/spells-teleport.h"
-#include "effect/attribute-types.h"
 #include "spell/spells-status.h"
 #include "status/action-setter.h"
 #include "status/body-improvement.h"
@@ -236,7 +236,7 @@ void process_surprise_attack(PlayerType *player_ptr, player_attack_type *pa_ptr)
         /* Can't backstab creatures that we can't see, right? */
         pa_ptr->backstab = true;
     } else if ((ninja_data && ninja_data->s_stealth) && (randint0(tmp) > (r_ptr->level + 20)) &&
-               pa_ptr->m_ptr->ml && !(r_ptr->flagsr & RFR_RES_ALL)) {
+               pa_ptr->m_ptr->ml && !r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         pa_ptr->surprise_attack = true;
     } else if (monster_fear_remaining(pa_ptr->m_ptr) && pa_ptr->m_ptr->ml) {
         pa_ptr->stab_fleeing = true;
@@ -474,7 +474,8 @@ bool cast_ninja_spell(PlayerType *player_ptr, mind_ninja_type spell)
     case PURGATORY_FLAME: {
         int num = damroll(3, 9);
         for (int k = 0; k < num; k++) {
-            AttributeType typ = one_in_(2) ? AttributeType::FIRE : one_in_(3) ? AttributeType::NETHER : AttributeType::PLASMA;
+            AttributeType typ = one_in_(2) ? AttributeType::FIRE : one_in_(3) ? AttributeType::NETHER
+                                                                              : AttributeType::PLASMA;
             int attempts = 1000;
             while (attempts--) {
                 scatter(player_ptr, &y, &x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);

diff --git a/src/mind/mind-samurai.cpp b/src/mind/mind-samurai.cpp
index 3e5148e..9f86ef5 100644 (file)
--- a/src/mind/mind-samurai.cpp
+++ b/src/mind/mind-samurai.cpp
@@ -18,6 +18,7 @@
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags-resistance.h"
 #include "monster-race/race-flags3.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-info.h"
 #include "monster/monster-status-setter.h"
@@ -72,21 +73,21 @@ static void hissatsu_burning_strike(PlayerType *player_ptr, samurai_slaying_type
         return;
 
     /* Notice immunity */
-    if (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK) {
+    if (samurai_slaying_ptr->r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_FIRE_MASK)) {
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-            samurai_slaying_ptr->r_ptr->r_flagsr |= (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK);
+            samurai_slaying_ptr->r_ptr->r_resistance_flags.set(samurai_slaying_ptr->r_ptr->resistance_flags & RFR_EFF_IM_FIRE_MASK);
 
         return;
     }
 
     /* Otherwise, take the damage */
     if (samurai_slaying_ptr->flags.has(TR_BRAND_FIRE)) {
-        if (samurai_slaying_ptr->r_ptr->flags3 & RF3_HURT_FIRE) {
+        if (samurai_slaying_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_FIRE)) {
             if (samurai_slaying_ptr->mult < 70)
                 samurai_slaying_ptr->mult = 70;
 
             if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-                samurai_slaying_ptr->r_ptr->r_flags3 |= RF3_HURT_FIRE;
+                samurai_slaying_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_FIRE);
 
         } else if (samurai_slaying_ptr->mult < 35)
             samurai_slaying_ptr->mult = 35;
@@ -94,12 +95,12 @@ static void hissatsu_burning_strike(PlayerType *player_ptr, samurai_slaying_type
         return;
     }
 
-    if (samurai_slaying_ptr->r_ptr->flags3 & RF3_HURT_FIRE) {
+    if (samurai_slaying_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_FIRE)) {
         if (samurai_slaying_ptr->mult < 50)
             samurai_slaying_ptr->mult = 50;
 
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-            samurai_slaying_ptr->r_ptr->r_flags3 |= RF3_HURT_FIRE;
+            samurai_slaying_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_FIRE);
     } else if (samurai_slaying_ptr->mult < 25)
         samurai_slaying_ptr->mult = 25;
 }
@@ -115,9 +116,9 @@ static void hissatsu_serpent_tongue(PlayerType *player_ptr, samurai_slaying_type
         return;
 
     /* Notice immunity */
-    if (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_POIS_MASK) {
+    if (samurai_slaying_ptr->r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_POISON_MASK)) {
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-            samurai_slaying_ptr->r_ptr->r_flagsr |= (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_POIS_MASK);
+            samurai_slaying_ptr->r_ptr->r_resistance_flags.set(samurai_slaying_ptr->r_ptr->resistance_flags & RFR_EFF_IM_POISON_MASK);
 
         return;
     }
@@ -157,9 +158,9 @@ static void hissatsu_rock_smash(PlayerType *player_ptr, samurai_slaying_type *sa
     if (samurai_slaying_ptr->mode != HISSATSU_HAGAN)
         return;
 
-    if (samurai_slaying_ptr->r_ptr->flags3 & RF3_HURT_ROCK) {
+    if (samurai_slaying_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_ROCK)) {
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-            samurai_slaying_ptr->r_ptr->r_flags3 |= RF3_HURT_ROCK;
+            samurai_slaying_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_ROCK);
 
         if (samurai_slaying_ptr->mult == 10)
             samurai_slaying_ptr->mult = 40;
@@ -179,33 +180,33 @@ static void hissatsu_midare_setsugetsuka(PlayerType *player_ptr, samurai_slaying
         return;
 
     /* Notice immunity */
-    if (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_COLD_MASK) {
+    if (samurai_slaying_ptr->r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_COLD_MASK)) {
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-            samurai_slaying_ptr->r_ptr->r_flagsr |= (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_COLD_MASK);
+            samurai_slaying_ptr->r_ptr->r_resistance_flags.set(samurai_slaying_ptr->r_ptr->resistance_flags & RFR_EFF_IM_COLD_MASK);
 
         return;
     }
 
     /* Otherwise, take the damage */
     if (samurai_slaying_ptr->flags.has(TR_BRAND_COLD)) {
-        if (samurai_slaying_ptr->r_ptr->flags3 & RF3_HURT_COLD) {
+        if (samurai_slaying_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_COLD)) {
             if (samurai_slaying_ptr->mult < 70)
                 samurai_slaying_ptr->mult = 70;
 
             if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-                samurai_slaying_ptr->r_ptr->r_flags3 |= RF3_HURT_COLD;
+                samurai_slaying_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_COLD);
         } else if (samurai_slaying_ptr->mult < 35)
             samurai_slaying_ptr->mult = 35;
 
         return;
     }
 
-    if (samurai_slaying_ptr->r_ptr->flags3 & RF3_HURT_COLD) {
+    if (samurai_slaying_ptr->r_ptr->resistance_flags.has(MonsterResistanceType::HURT_COLD)) {
         if (samurai_slaying_ptr->mult < 50)
             samurai_slaying_ptr->mult = 50;
 
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-            samurai_slaying_ptr->r_ptr->r_flags3 |= RF3_HURT_COLD;
+            samurai_slaying_ptr->r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_COLD);
     } else if (samurai_slaying_ptr->mult < 25)
         samurai_slaying_ptr->mult = 25;
 }
@@ -221,9 +222,9 @@ static void hissatsu_lightning_eagle(PlayerType *player_ptr, samurai_slaying_typ
         return;
 
     /* Notice immunity */
-    if (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK) {
+    if (samurai_slaying_ptr->r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_ELEC_MASK)) {
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr))
-            samurai_slaying_ptr->r_ptr->r_flagsr |= (samurai_slaying_ptr->r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK);
+            samurai_slaying_ptr->r_ptr->r_resistance_flags.set(samurai_slaying_ptr->r_ptr->resistance_flags & RFR_EFF_IM_ELEC_MASK);
 
         return;
     }

diff --git a/src/mind/mind-sniper.cpp b/src/mind/mind-sniper.cpp
index a6fff76..de96a02 100644 (file)
--- a/src/mind/mind-sniper.cpp
+++ b/src/mind/mind-sniper.cpp
@@ -421,23 +421,23 @@ MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, mons
 
     switch (snipe_type) {
     case SP_LITE:
-        if (r_ptr->flags3 & (RF3_HURT_LITE)) {
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::HURT_LITE)) {
             MULTIPLY n = 20 + sniper_concent;
             if (seen)
-                r_ptr->r_flags3 |= (RF3_HURT_LITE);
+                r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_LITE);
             if (mult < n)
                 mult = n;
         }
         break;
     case SP_FIRE:
-        if (r_ptr->flagsr & RFR_IM_FIRE) {
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_FIRE)) {
             if (seen)
-                r_ptr->r_flagsr |= RFR_IM_FIRE;
+                r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_FIRE);
         } else {
             MULTIPLY n;
-            if (r_ptr->flags3 & RF3_HURT_FIRE) {
+            if (r_ptr->resistance_flags.has(MonsterResistanceType::HURT_FIRE)) {
                 n = 22 + (sniper_concent * 4);
-                r_ptr->r_flags3 |= RF3_HURT_FIRE;
+                r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_FIRE);
             } else
                 n = 15 + (sniper_concent * 3);
 
@@ -446,14 +446,14 @@ MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, mons
         }
         break;
     case SP_COLD:
-        if (r_ptr->flagsr & RFR_IM_COLD) {
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_COLD)) {
             if (seen)
-                r_ptr->r_flagsr |= RFR_IM_COLD;
+                r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_COLD);
         } else {
             MULTIPLY n;
-            if (r_ptr->flags3 & RF3_HURT_COLD) {
+            if (r_ptr->resistance_flags.has(MonsterResistanceType::HURT_COLD)) {
                 n = 22 + (sniper_concent * 4);
-                r_ptr->r_flags3 |= RF3_HURT_COLD;
+                r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_COLD);
             } else
                 n = 15 + (sniper_concent * 3);
 
@@ -462,9 +462,9 @@ MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, mons
         }
         break;
     case SP_ELEC:
-        if (r_ptr->flagsr & RFR_IM_ELEC) {
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_ELEC)) {
             if (seen)
-                r_ptr->r_flagsr |= RFR_IM_ELEC;
+                r_ptr->r_resistance_flags.set(MonsterResistanceType::IMMUNE_ELEC);
         } else {
             MULTIPLY n = 18 + (sniper_concent * 4);
             if (mult < n)
@@ -472,10 +472,10 @@ MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, mons
         }
         break;
     case SP_KILL_WALL:
-        if (r_ptr->flags3 & RF3_HURT_ROCK) {
+        if (r_ptr->resistance_flags.has(MonsterResistanceType::HURT_ROCK)) {
             MULTIPLY n = 15 + (sniper_concent * 2);
             if (seen)
-                r_ptr->r_flags3 |= RF3_HURT_ROCK;
+                r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_ROCK);
             if (mult < n)
                 mult = n;
         } else if (r_ptr->kind_flags.has(MonsterKindType::NONLIVING)) {
@@ -500,10 +500,10 @@ MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, mons
             MULTIPLY n = 12 + (sniper_concent * 3);
             if (seen)
                 r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
-            if (r_ptr->flags3 & (RF3_HURT_LITE)) {
+            if (r_ptr->resistance_flags.has(MonsterResistanceType::HURT_LITE)) {
                 n += (sniper_concent * 3);
                 if (seen)
-                    r_ptr->r_flags3 |= (RF3_HURT_LITE);
+                    r_ptr->r_resistance_flags.set(MonsterResistanceType::HURT_LITE);
             }
             if (mult < n)
                 mult = n;

diff --git a/src/monster-floor/monster-object.cpp b/src/monster-floor/monster-object.cpp
index 24e73ff..e152132 100644 (file)
--- a/src/monster-floor/monster-object.cpp
+++ b/src/monster-floor/monster-object.cpp
@@ -13,6 +13,7 @@
 #include "monster-race/race-flags-resistance.h"
 #include "monster-race/race-flags2.h"
 #include "monster-race/race-flags3.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-description-types.h"
 #include "monster/monster-info.h"
@@ -33,7 +34,7 @@
 /*!
  * @brief オブジェクトのフラグを更新する
  */
-static void update_object_flags(const TrFlags &flgs, EnumClassFlagGroup<MonsterKindType> &flg_monster_kind, BIT_FLAGS *flgr)
+static void update_object_flags(const TrFlags &flgs, EnumClassFlagGroup<MonsterKindType> &flg_monster_kind, EnumClassFlagGroup<MonsterResistanceType> &flgr)
 {
     if (flgs.has(TR_SLAY_DRAGON))
         flg_monster_kind.set(MonsterKindType::DRAGON);
@@ -76,15 +77,15 @@ static void update_object_flags(const TrFlags &flgs, EnumClassFlagGroup<MonsterK
     if (flgs.has(TR_KILL_HUMAN))
         flg_monster_kind.set(MonsterKindType::HUMAN);
     if (flgs.has(TR_BRAND_ACID))
-        *flgr |= (RFR_IM_ACID);
+        flgr.set(MonsterResistanceType::IMMUNE_ACID);
     if (flgs.has(TR_BRAND_ELEC))
-        *flgr |= (RFR_IM_ELEC);
+        flgr.set(MonsterResistanceType::IMMUNE_ELEC);
     if (flgs.has(TR_BRAND_FIRE))
-        *flgr |= (RFR_IM_FIRE);
+        flgr.set(MonsterResistanceType::IMMUNE_FIRE);
     if (flgs.has(TR_BRAND_COLD))
-        *flgr |= (RFR_IM_COLD);
+        flgr.set(MonsterResistanceType::IMMUNE_COLD);
     if (flgs.has(TR_BRAND_POIS))
-        *flgr |= (RFR_IM_POIS);
+        flgr.set(MonsterResistanceType::IMMUNE_POISON);
 }
 
 /*!
@@ -159,7 +160,7 @@ void update_object_by_monster_movement(PlayerType *player_ptr, turn_flags *turn_
     turn_flags_ptr->do_take = r_ptr->behavior_flags.has(MonsterBehaviorType::TAKE_ITEM);
     for (auto it = g_ptr->o_idx_list.begin(); it != g_ptr->o_idx_list.end();) {
         EnumClassFlagGroup<MonsterKindType> flg_monster_kind;
-        BIT_FLAGS flgr = 0L;
+        EnumClassFlagGroup<MonsterResistanceType> flgr;
         GAME_TEXT m_name[MAX_NLEN], o_name[MAX_NLEN];
         OBJECT_IDX this_o_idx = *it++;
         auto *o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
@@ -173,9 +174,12 @@ void update_object_by_monster_movement(PlayerType *player_ptr, turn_flags *turn_
         auto flgs = object_flags(o_ptr);
         describe_flavor(player_ptr, o_name, o_ptr, 0);
         monster_desc(player_ptr, m_name, m_ptr, MD_INDEF_HIDDEN);
-        update_object_flags(flgs, flg_monster_kind, &flgr);
+        update_object_flags(flgs, flg_monster_kind, flgr);
 
-        bool is_special_object = o_ptr->is_artifact() || r_ptr->kind_flags.has_any_of(flg_monster_kind) || (((~(r_ptr->flagsr) & flgr) != 0) && !(r_ptr->flagsr & RFR_RES_ALL));
+        EnumClassFlagGroup<MonsterResistanceType> has_resistance_flags(r_ptr->resistance_flags & flgr);
+        bool is_special_object = o_ptr->is_artifact();
+        is_special_object |= r_ptr->kind_flags.has_any_of(flg_monster_kind);
+        is_special_object |= has_resistance_flags.count() != has_resistance_flags.size() && r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_ALL);
         monster_pickup_object(player_ptr, turn_flags_ptr, m_idx, o_ptr, is_special_object, ny, nx, m_name, o_name, this_o_idx);
     }
 }

diff --git a/src/monster-race/monster-race-hook.cpp b/src/monster-race/monster-race-hook.cpp
index a18d1c2..9b0859f 100644 (file)
--- a/src/monster-race/monster-race-hook.cpp
+++ b/src/monster-race/monster-race-hook.cpp
@@ -289,7 +289,7 @@ bool mon_hook_lava(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!mon_hook_dungeon(player_ptr, r_idx))
         return false;
 
-    return (any_bits(r_ptr->flagsr, RFR_EFF_IM_FIRE_MASK) || any_bits(r_ptr->flags7, RF7_CAN_FLY)) && r_ptr->aura_flags.has_not(MonsterAuraType::COLD);
+    return (r_ptr->resistance_flags.has_any_of(RFR_EFF_IM_FIRE_MASK) || any_bits(r_ptr->flags7, RF7_CAN_FLY)) && r_ptr->aura_flags.has_not(MonsterAuraType::COLD);
 }
 
 /*!
@@ -864,7 +864,7 @@ bool item_monster_okay(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (any_bits(r_ptr->flags7, RF7_KAGE))
         return false;
 
-    if (any_bits(r_ptr->flagsr, RFR_RES_ALL))
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL))
         return false;
 
     if (any_bits(r_ptr->flags7, RF7_NAZGUL))
@@ -890,5 +890,5 @@ bool item_monster_okay(PlayerType *player_ptr, MONRACE_IDX r_idx)
  */
 bool vault_monster_okay(PlayerType *player_ptr, MONRACE_IDX r_idx)
 {
-    return mon_hook_dungeon(player_ptr, r_idx) && r_info[r_idx].kind_flags.has_not(MonsterKindType::UNIQUE) && none_bits(r_info[r_idx].flags7, RF7_UNIQUE2) && none_bits(r_info[r_idx].flagsr, RFR_RES_ALL) && none_bits(r_info[r_idx].flags7, RF7_AQUATIC);
+    return mon_hook_dungeon(player_ptr, r_idx) && r_info[r_idx].kind_flags.has_not(MonsterKindType::UNIQUE) && none_bits(r_info[r_idx].flags7, RF7_UNIQUE2) && r_info[r_idx].resistance_flags.has_not(MonsterResistanceType::RESIST_ALL) && none_bits(r_info[r_idx].flags7, RF7_AQUATIC);
 }

diff --git a/src/monster-race/monster-race.cpp b/src/monster-race/monster-race.cpp
index 6a1d216..d36c4fd 100644 (file)
--- a/src/monster-race/monster-race.cpp
+++ b/src/monster-race/monster-race.cpp
@@ -1,6 +1,7 @@
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags-resistance.h"
 #include "monster-race/race-flags1.h"
+#include "monster-race/race-resistance-mask.h"
 #include "system/monster-race-definition.h"
 
 /* The monster race arrays */
@@ -9,7 +10,7 @@ std::vector<monster_race> r_info;
 int calc_monrace_power(monster_race *r_ptr)
 {
     int ret = 0;
-    int num_taisei = count_bits(r_ptr->flagsr & (RFR_IM_ACID | RFR_IM_ELEC | RFR_IM_FIRE | RFR_IM_COLD | RFR_IM_POIS));
+    int num_taisei = EnumClassFlagGroup<MonsterResistanceType>(r_ptr->resistance_flags & RFR_EFF_IMMUNE_ELEMENT_MASK).count();
 
     if (r_ptr->flags1 & RF1_FORCE_MAXHP)
         ret = r_ptr->hdice * r_ptr->hside * 2;
@@ -32,7 +33,7 @@ int calc_monrace_power(monster_race *r_ptr)
         ret = ret * 9 / 10;
     if (r_ptr->behavior_flags.has(MonsterBehaviorType::RAND_MOVE_50))
         ret = ret * 9 / 10;
-    if (r_ptr->flagsr & RFR_RES_ALL)
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL))
         ret *= 100000;
     if (r_ptr->arena_ratio)
         ret = ret * r_ptr->arena_ratio / 100;

diff --git a/src/monster/monster-info.cpp b/src/monster/monster-info.cpp
index 23f4d46..967b82d 100644 (file)
--- a/src/monster/monster-info.cpp
+++ b/src/monster/monster-info.cpp
@@ -21,6 +21,7 @@
 #include "monster-race/race-flags7.h"
 #include "monster-race/race-flags8.h"
 #include "monster-race/race-indice-types.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-flag-types.h"
 #include "monster/monster-status.h"
@@ -92,27 +93,27 @@ bool monster_can_cross_terrain(PlayerType *player_ptr, FEAT_IDX feat, monster_ra
         return false;
 
     if (f_ptr->flags.has(FloorFeatureType::LAVA)) {
-        if (!(r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK))
+        if (r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_FIRE_MASK))
             return false;
     }
 
     if (f_ptr->flags.has(FloorFeatureType::COLD_PUDDLE)) {
-        if (!(r_ptr->flagsr & RFR_EFF_IM_COLD_MASK))
+        if (r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_COLD_MASK))
             return false;
     }
 
     if (f_ptr->flags.has(FloorFeatureType::ELEC_PUDDLE)) {
-        if (!(r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK))
+        if (r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_ELEC_MASK))
             return false;
     }
 
     if (f_ptr->flags.has(FloorFeatureType::ACID_PUDDLE)) {
-        if (!(r_ptr->flagsr & RFR_EFF_IM_ACID_MASK))
+        if (r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_ACID_MASK))
             return false;
     }
 
     if (f_ptr->flags.has(FloorFeatureType::POISON_PUDDLE)) {
-        if (!(r_ptr->flagsr & RFR_EFF_IM_POIS_MASK))
+        if (r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_POISON_MASK))
             return false;
     }
 

diff --git a/src/monster/monster-processor-util.cpp b/src/monster/monster-processor-util.cpp
index 0434bb2..e3cfbd4 100644 (file)
--- a/src/monster/monster-processor-util.cpp
+++ b/src/monster/monster-processor-util.cpp
@@ -45,7 +45,7 @@ old_race_flags *init_old_race_flags(old_race_flags *old_race_flags_ptr)
     old_race_flags_ptr->old_r_flags1 = 0L;
     old_race_flags_ptr->old_r_flags2 = 0L;
     old_race_flags_ptr->old_r_flags3 = 0L;
-    old_race_flags_ptr->old_r_flagsr = 0L;
+    old_race_flags_ptr->old_r_resistance_flags.clear();
     old_race_flags_ptr->old_r_ability_flags.clear();
     old_race_flags_ptr->old_r_behavior_flags.clear();
     old_race_flags_ptr->old_r_kind_flags.clear();
@@ -291,7 +291,7 @@ void save_old_race_flags(MONRACE_IDX monster_race_idx, old_race_flags *old_race_
     old_race_flags_ptr->old_r_flags1 = r_ptr->r_flags1;
     old_race_flags_ptr->old_r_flags2 = r_ptr->r_flags2;
     old_race_flags_ptr->old_r_flags3 = r_ptr->r_flags3;
-    old_race_flags_ptr->old_r_flagsr = r_ptr->r_flagsr;
+    old_race_flags_ptr->old_r_resistance_flags = r_ptr->r_resistance_flags;
     old_race_flags_ptr->old_r_ability_flags = r_ptr->r_ability_flags;
     old_race_flags_ptr->old_r_behavior_flags = r_ptr->r_behavior_flags;
 

diff --git a/src/monster/monster-processor-util.h b/src/monster/monster-processor-util.h
index f89bb8b..fd02c2a 100644 (file)
--- a/src/monster/monster-processor-util.h
+++ b/src/monster/monster-processor-util.h
@@ -36,6 +36,7 @@ struct old_race_flags {
     BIT_FLAGS old_r_flags1;
     BIT_FLAGS old_r_flags2;
     BIT_FLAGS old_r_flags3;
+    BIT_FLAGS old_r_flagsr;
     EnumClassFlagGroup<MonsterAbilityType> old_r_ability_flags;
     EnumClassFlagGroup<MonsterBehaviorType> old_r_behavior_flags;
     EnumClassFlagGroup<MonsterKindType> old_r_kind_flags;

diff --git a/src/monster/monster-processor.cpp b/src/monster/monster-processor.cpp
index ff35f46..d82fee2 100644 (file)
--- a/src/monster/monster-processor.cpp
+++ b/src/monster/monster-processor.cpp
@@ -311,7 +311,7 @@ void process_angar(PlayerType *player_ptr, MONSTER_IDX m_idx, bool see_m)
     if (is_friendly(m_ptr) && has_aggravate(player_ptr))
         gets_angry = true;
 
-    if (is_pet(m_ptr) && (((r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)) && monster_has_hostile_align(player_ptr, nullptr, 10, -10, r_ptr)) || (r_ptr->flagsr & RFR_RES_ALL)))
+    if (is_pet(m_ptr) && (((r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)) && monster_has_hostile_align(player_ptr, nullptr, 10, -10, r_ptr)) || r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)))
         gets_angry = true;
 
     if (player_ptr->phase_out || !gets_angry)

diff --git a/src/monster/monster-status.cpp b/src/monster/monster-status.cpp
index e217ddf..8ca77b3 100644 (file)
--- a/src/monster/monster-status.cpp
+++ b/src/monster/monster-status.cpp
@@ -71,7 +71,7 @@ DEPTH monster_level_idx(floor_type *floor_ptr, MONSTER_IDX m_idx)
 int mon_damage_mod(PlayerType *player_ptr, monster_type *m_ptr, int dam, bool is_psy_spear)
 {
     auto *r_ptr = &r_info[m_ptr->r_idx];
-    if ((r_ptr->flagsr & RFR_RES_ALL) && dam > 0) {
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL) && dam > 0) {
         dam /= 100;
         if ((dam == 0) && one_in_(3)) {
             dam = 1;

diff --git a/src/monster/monster-update.cpp b/src/monster/monster-update.cpp
index 7d72800..c056060 100644 (file)
--- a/src/monster/monster-update.cpp
+++ b/src/monster/monster-update.cpp
@@ -155,7 +155,7 @@ void update_player_window(PlayerType *player_ptr, old_race_flags *old_race_flags
     r_ptr = &r_info[player_ptr->monster_race_idx];
     if ((old_race_flags_ptr->old_r_flags1 != r_ptr->r_flags1) || (old_race_flags_ptr->old_r_flags2 != r_ptr->r_flags2) ||
         (old_race_flags_ptr->old_r_flags3 != r_ptr->r_flags3) || (old_race_flags_ptr->old_r_ability_flags != r_ptr->r_ability_flags) ||
-        (old_race_flags_ptr->old_r_flagsr != r_ptr->r_flagsr) || (old_race_flags_ptr->old_r_blows0 != r_ptr->r_blows[0]) ||
+        (old_race_flags_ptr->old_r_resistance_flags != r_ptr->r_resistance_flags) || (old_race_flags_ptr->old_r_blows0 != r_ptr->r_blows[0]) ||
         (old_race_flags_ptr->old_r_blows1 != r_ptr->r_blows[1]) || (old_race_flags_ptr->old_r_blows2 != r_ptr->r_blows[2]) ||
         (old_race_flags_ptr->old_r_blows3 != r_ptr->r_blows[3]) || (old_race_flags_ptr->old_r_cast_spell != r_ptr->r_cast_spell) ||
         (old_race_flags_ptr->old_r_behavior_flags != r_ptr->r_behavior_flags) || (old_race_flags_ptr->old_r_kind_flags != r_ptr->r_kind_flags)) {

diff --git a/src/monster/monster-util.cpp b/src/monster/monster-util.cpp
index a91177f..1f97c1c 100644 (file)
--- a/src/monster/monster-util.cpp
+++ b/src/monster/monster-util.cpp
@@ -129,8 +129,8 @@ static bool restrict_monster_to_dungeon(PlayerType *player_ptr, MONRACE_IDX r_id
                 return false;
         }
 
-        if (d_ptr->mflagsr) {
-            if ((d_ptr->mflagsr & r_ptr->flagsr) != d_ptr->mflagsr)
+        if (d_ptr->mon_resistance_flags.any()) {
+            if (!d_ptr->mon_resistance_flags.has_all_of(r_ptr->resistance_flags))
                 return false;
         }
 
@@ -181,8 +181,8 @@ static bool restrict_monster_to_dungeon(PlayerType *player_ptr, MONRACE_IDX r_id
                 return true;
         }
 
-        if (d_ptr->mflagsr) {
-            if ((d_ptr->mflagsr & r_ptr->flagsr) != d_ptr->mflagsr)
+        if (d_ptr->mon_resistance_flags.any()) {
+            if (!d_ptr->mon_resistance_flags.has_all_of(r_ptr->resistance_flags))
                 return true;
         }
 
@@ -209,7 +209,7 @@ static bool restrict_monster_to_dungeon(PlayerType *player_ptr, MONRACE_IDX r_id
             return true;
         if (r_ptr->flags9 & d_ptr->mflags9)
             return true;
-        if (r_ptr->flagsr & d_ptr->mflagsr)
+        if (r_ptr->resistance_flags.has_any_of(d_ptr->mon_resistance_flags))
             return true;
         for (a = 0; a < 5; a++)
             if (d_ptr->r_char[a] == r_ptr->d_char)
@@ -234,7 +234,7 @@ static bool restrict_monster_to_dungeon(PlayerType *player_ptr, MONRACE_IDX r_id
             return false;
         if (r_ptr->flags9 & d_ptr->mflags9)
             return false;
-        if (r_ptr->flagsr & d_ptr->mflagsr)
+        if (r_ptr->resistance_flags.has_any_of(d_ptr->mon_resistance_flags))
             return false;
         for (a = 0; a < 5; a++)
             if (d_ptr->r_char[a] == r_ptr->d_char)
@@ -351,7 +351,7 @@ static errr do_get_mon_num_prep(PlayerType *player_ptr, const monsterrace_hook_t
                 continue;
 
             // クエスト内でRES_ALLの生成を禁止する (殲滅系クエストの詰み防止)
-            if (inside_quest(player_ptr->current_floor_ptr->quest_number) && any_bits(r_ptr->flagsr, RFR_RES_ALL))
+            if (inside_quest(player_ptr->current_floor_ptr->quest_number) && r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL))
                 continue;
         }
 

diff --git a/src/mspell/mspell-floor.cpp b/src/mspell/mspell-floor.cpp
index 6082887..7b6b03b 100644 (file)
--- a/src/mspell/mspell-floor.cpp
+++ b/src/mspell/mspell-floor.cpp
@@ -19,6 +19,7 @@
 #include "monster-race/race-flags3.h"
 #include "monster-race/race-flags7.h"
 #include "monster-race/race-indice-types.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-info.h"
 #include "monster/monster-status-setter.h"
 #include "monster/monster-status.h"
@@ -196,17 +197,17 @@ MonsterSpellResult spell_RF6_TELE_TO(PlayerType *player_ptr, MONSTER_IDX m_idx,
     GAME_TEXT t_name[MAX_NLEN];
     monster_name(player_ptr, t_idx, t_name);
 
-    if (tr_ptr->flagsr & RFR_RES_TELE) {
-        if (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL)) {
+    if (tr_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
+        if (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE) || tr_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
             if (is_original_ap_and_seen(player_ptr, t_ptr))
-                tr_ptr->r_flagsr |= RFR_RES_TELE;
+                tr_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
             if (see_monster(player_ptr, t_idx)) {
                 msg_format(_("%^sには効果がなかった。", "%^s is unaffected!"), t_name);
             }
             resists_tele = true;
         } else if (tr_ptr->level > randint1(100)) {
             if (is_original_ap_and_seen(player_ptr, t_ptr))
-                tr_ptr->r_flagsr |= RFR_RES_TELE;
+                tr_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
             if (see_monster(player_ptr, t_idx)) {
                 msg_format(_("%^sは耐性を持っている！", "%^s resists!"), t_name);
             }
@@ -272,17 +273,17 @@ MonsterSpellResult spell_RF6_TELE_AWAY(PlayerType *player_ptr, MONSTER_IDX m_idx
     GAME_TEXT t_name[MAX_NLEN];
     monster_name(player_ptr, t_idx, t_name);
 
-    if (tr_ptr->flagsr & RFR_RES_TELE) {
-        if (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL)) {
+    if (tr_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
+        if (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE) || tr_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
             if (is_original_ap_and_seen(player_ptr, t_ptr))
-                tr_ptr->r_flagsr |= RFR_RES_TELE;
+                tr_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
             if (see_monster(player_ptr, t_idx)) {
                 msg_format(_("%^sには効果がなかった。", "%^s is unaffected!"), t_name);
             }
             resists_tele = true;
         } else if (tr_ptr->level > randint1(100)) {
             if (is_original_ap_and_seen(player_ptr, t_ptr))
-                tr_ptr->r_flagsr |= RFR_RES_TELE;
+                tr_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
             if (see_monster(player_ptr, t_idx)) {
                 msg_format(_("%^sは耐性を持っている！", "%^s resists!"), t_name);
             }
@@ -344,7 +345,7 @@ MonsterSpellResult spell_RF6_TELE_LEVEL(PlayerType *player_ptr, MONSTER_IDX m_id
     if (TARGET_TYPE != MONSTER_TO_MONSTER)
         return res;
 
-    resist = tr_ptr->flagsr & (RFR_EFF_RES_NEXU_MASK | RFR_RES_TELE);
+    resist = tr_ptr->resistance_flags.has_any_of(RFR_EFF_RESIST_NEXUS_MASK) || tr_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT);
     saving_throw = (tr_ptr->flags1 & RF1_QUESTOR) || (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
 
     mspell_cast_msg_bad_status_to_monster msg(_("%^sが%sの足を指さした。", "%^s gestures at %s's feet."),
@@ -384,7 +385,7 @@ MonsterSpellResult spell_RF6_DARKNESS(PlayerType *player_ptr, POSITION y, POSITI
     GAME_TEXT t_name[MAX_NLEN];
     monster_name(player_ptr, t_idx, t_name);
 
-    if (PlayerClass(player_ptr).equals(PlayerClassType::NINJA) && r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) && none_bits(r_ptr->flags3, RF3_HURT_LITE) && !(r_ptr->flags7 & RF7_DARK_MASK))
+    if (PlayerClass(player_ptr).equals(PlayerClassType::NINJA) && r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) && r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_LITE) && !(r_ptr->flags7 & RF7_DARK_MASK))
         can_use_lite_area = true;
 
     if (monster_to_monster && !is_hostile(t_ptr))

diff --git a/src/mspell/mspell-judgement.cpp b/src/mspell/mspell-judgement.cpp
index dff8617..1b10515 100644 (file)
--- a/src/mspell/mspell-judgement.cpp
+++ b/src/mspell/mspell-judgement.cpp
@@ -309,19 +309,19 @@ bool dispel_check(PlayerType *player_ptr, MONSTER_IDX m_idx)
     if (player_ptr->tsuyoshi)
         return true;
 
-    if ((player_ptr->special_attack & ATTACK_ACID) && !(r_ptr->flagsr & RFR_EFF_IM_ACID_MASK))
+    if ((player_ptr->special_attack & ATTACK_ACID) && r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_ACID_MASK))
         return true;
 
-    if ((player_ptr->special_attack & ATTACK_FIRE) && !(r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK))
+    if ((player_ptr->special_attack & ATTACK_FIRE) && r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_FIRE_MASK))
         return true;
 
-    if ((player_ptr->special_attack & ATTACK_ELEC) && !(r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK))
+    if ((player_ptr->special_attack & ATTACK_ELEC) && r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_ELEC_MASK))
         return true;
 
-    if ((player_ptr->special_attack & ATTACK_COLD) && !(r_ptr->flagsr & RFR_EFF_IM_COLD_MASK))
+    if ((player_ptr->special_attack & ATTACK_COLD) && r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_COLD_MASK))
         return true;
 
-    if ((player_ptr->special_attack & ATTACK_POIS) && !(r_ptr->flagsr & RFR_EFF_IM_POIS_MASK))
+    if ((player_ptr->special_attack & ATTACK_POIS) && r_ptr->resistance_flags.has_none_of(RFR_EFF_IM_POISON_MASK))
         return true;
 
     if ((player_ptr->pspeed < 145) && is_fast(player_ptr))

diff --git a/src/mspell/mspell-lite.cpp b/src/mspell/mspell-lite.cpp
index 5914b80..684732e 100644 (file)
--- a/src/mspell/mspell-lite.cpp
+++ b/src/mspell/mspell-lite.cpp
@@ -180,7 +180,7 @@ void decide_lite_area(PlayerType *player_ptr, msa_type *msa_ptr)
         return;
 
     PlayerClass pc(player_ptr);
-    bool can_use_lite_area = pc.equals(PlayerClassType::NINJA) && msa_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) && none_bits(msa_ptr->r_ptr->flags3, RF3_HURT_LITE) && ((msa_ptr->r_ptr->flags7 & RF7_DARK_MASK) == 0);
+    bool can_use_lite_area = pc.equals(PlayerClassType::NINJA) && msa_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) && msa_ptr->r_ptr->resistance_flags.has_not(MonsterResistanceType::HURT_LITE) && ((msa_ptr->r_ptr->flags7 & RF7_DARK_MASK) == 0);
 
     if (msa_ptr->r_ptr->behavior_flags.has(MonsterBehaviorType::STUPID))
         return;

diff --git a/src/object-enchant/vorpal-weapon.cpp b/src/object-enchant/vorpal-weapon.cpp
index 47c0810..fbaf820 100644 (file)
--- a/src/object-enchant/vorpal-weapon.cpp
+++ b/src/object-enchant/vorpal-weapon.cpp
@@ -91,7 +91,7 @@ void process_vorpal_attack(PlayerType *player_ptr, player_attack_type *pa_ptr, c
 
     pa_ptr->attack_damage *= (int)vorpal_magnification;
     auto *r_ptr = &r_info[pa_ptr->m_ptr->r_idx];
-    if (((r_ptr->flagsr & RFR_RES_ALL) ? pa_ptr->attack_damage / 100 : pa_ptr->attack_damage) > pa_ptr->m_ptr->hp)
+    if ((r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL) ? pa_ptr->attack_damage / 100 : pa_ptr->attack_damage) > pa_ptr->m_ptr->hp)
         msg_format(_("%sを真っ二つにした！", "You cut %s in half!"), pa_ptr->m_name);
     else
         print_vorpal_message(pa_ptr, vorpal_magnification);

diff --git a/src/player-attack/attack-chaos-effect.cpp b/src/player-attack/attack-chaos-effect.cpp
index f92f04d..3871877 100644 (file)
--- a/src/player-attack/attack-chaos-effect.cpp
+++ b/src/player-attack/attack-chaos-effect.cpp
@@ -19,6 +19,7 @@
 #include "monster-race/race-flags-resistance.h"
 #include "monster-race/race-flags1.h"
 #include "monster-race/race-flags3.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-info.h"
 #include "monster/monster-status-setter.h"
@@ -170,12 +171,12 @@ static void attack_probe(PlayerType *player_ptr, player_attack_type *pa_ptr)
 static bool judge_tereprt_resistance(PlayerType *player_ptr, player_attack_type *pa_ptr)
 {
     auto *r_ptr = pa_ptr->r_ptr;
-    if ((r_ptr->flagsr & RFR_RES_TELE) == 0)
+    if (r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_TELEPORT))
         return false;
 
     if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         if (is_original_ap_and_seen(player_ptr, pa_ptr->m_ptr))
-            r_ptr->r_flagsr |= RFR_RES_TELE;
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
 
         msg_format(_("%^sには効果がなかった。", "%^s is unaffected!"), pa_ptr->m_name);
         return true;
@@ -183,7 +184,7 @@ static bool judge_tereprt_resistance(PlayerType *player_ptr, player_attack_type
 
     if (r_ptr->level > randint1(100)) {
         if (is_original_ap_and_seen(player_ptr, pa_ptr->m_ptr))
-            r_ptr->r_flagsr |= RFR_RES_TELE;
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
 
         msg_format(_("%^sは抵抗力を持っている！", "%^s resists!"), pa_ptr->m_name);
         return true;
@@ -219,7 +220,7 @@ static void attack_teleport_away(PlayerType *player_ptr, player_attack_type *pa_
 static void attack_polymorph(PlayerType *player_ptr, player_attack_type *pa_ptr, POSITION y, POSITION x)
 {
     auto *r_ptr = pa_ptr->r_ptr;
-    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(r_ptr->flags1, RF1_QUESTOR) || ((r_ptr->flagsr & RFR_EFF_RES_CHAO_MASK) != 0))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(r_ptr->flags1, RF1_QUESTOR) || r_ptr->resistance_flags.has_any_of(RFR_EFF_RESIST_CHAOS_MASK))
         return;
 
     if (polymorph_monster(player_ptr, y, x)) {

diff --git a/src/spell-kind/spells-teleport.cpp b/src/spell-kind/spells-teleport.cpp
index ea9a068..b801e06 100644 (file)
--- a/src/spell-kind/spells-teleport.cpp
+++ b/src/spell-kind/spells-teleport.cpp
@@ -86,10 +86,10 @@ bool teleport_swap(PlayerType *player_ptr, DIRECTION dir)
 
     (void)set_monster_csleep(player_ptr, g_ptr->m_idx, 0);
 
-    if (r_ptr->flagsr & RFR_RES_TELE) {
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT)) {
         msg_print(_("テレポートを邪魔された！", "Your teleportation is blocked!"));
         if (is_original_ap_and_seen(player_ptr, m_ptr))
-            r_ptr->r_flagsr |= RFR_RES_TELE;
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_TELEPORT);
         return false;
     }
 
@@ -390,7 +390,7 @@ void teleport_player(PlayerType *player_ptr, POSITION dis, BIT_FLAGS mode)
                 auto *r_ptr = &r_info[m_ptr->r_idx];
 
                 bool can_follow = r_ptr->ability_flags.has(MonsterAbilityType::TPORT);
-                can_follow &= none_bits(r_ptr->flagsr, RFR_RES_TELE);
+                can_follow &= r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_TELEPORT);
                 can_follow &= monster_csleep_remaining(m_ptr) == 0;
                 if (can_follow) {
                     teleport_monster_to(player_ptr, tmp_m_idx, player_ptr->y, player_ptr->x, r_ptr->level, TELEPORT_SPONTANEOUS);
@@ -433,7 +433,7 @@ void teleport_player_away(MONSTER_IDX m_idx, PlayerType *player_ptr, POSITION di
             auto *r_ptr = &r_info[m_ptr->r_idx];
 
             bool can_follow = r_ptr->ability_flags.has(MonsterAbilityType::TPORT);
-            can_follow &= none_bits(r_ptr->flagsr, RFR_RES_TELE);
+            can_follow &= r_ptr->resistance_flags.has_not(MonsterResistanceType::RESIST_TELEPORT);
             can_follow &= monster_csleep_remaining(m_ptr) == 0;
             if (can_follow) {
                 teleport_monster_to(player_ptr, tmp_m_idx, player_ptr->y, player_ptr->x, r_ptr->level, TELEPORT_SPONTANEOUS);

diff --git a/src/spell-kind/spells-world.cpp b/src/spell-kind/spells-world.cpp
index 9b81df1..0e17798 100644 (file)
--- a/src/spell-kind/spells-world.cpp
+++ b/src/spell-kind/spells-world.cpp
@@ -20,8 +20,10 @@
 #include "market/building-util.h"
 #include "monster-floor/monster-remover.h"
 #include "monster-race/monster-race.h"
+#include "monster-race/race-ability-mask.h"
 #include "monster-race/race-flags-resistance.h"
 #include "monster-race/race-flags1.h"
+#include "monster-race/race-resistance-mask.h"
 #include "monster/monster-describer.h"
 #include "monster/monster-description-types.h"
 #include "monster/monster-info.h"
@@ -230,7 +232,9 @@ bool teleport_level_other(PlayerType *player_ptr)
     monster_desc(player_ptr, m_name, m_ptr, 0);
     msg_format(_("%^sの足を指さした。", "You gesture at %^s's feet."), m_name);
 
-    if ((r_ptr->flagsr & (RFR_EFF_RES_NEXU_MASK | RFR_RES_TELE)) || (r_ptr->flags1 & RF1_QUESTOR) || (r_ptr->level + randint1(50) > player_ptr->lev + randint1(60))) {
+    auto has_immune = r_ptr->resistance_flags.has_any_of(RFR_EFF_RESIST_NEXUS_MASK) || r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT);
+
+    if (has_immune || (r_ptr->flags1 & RF1_QUESTOR) || (r_ptr->level + randint1(50) > player_ptr->lev + randint1(60))) {
         msg_format(_("しかし効果がなかった！", "%^s is unaffected!"), m_name);
     } else {
         teleport_level(player_ptr, target_m_idx);

diff --git a/src/spell/spells-diceroll.cpp b/src/spell/spells-diceroll.cpp
index 192812b..be14307 100644 (file)
--- a/src/spell/spells-diceroll.cpp
+++ b/src/spell/spells-diceroll.cpp
@@ -30,9 +30,9 @@ bool common_saving_throw_charm(PlayerType *player_ptr, int pow, monster_type *m_
         return true;
 
     /* Memorize a flag */
-    if (r_ptr->flagsr & RFR_RES_ALL) {
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         if (is_original_ap_and_seen(player_ptr, m_ptr))
-            r_ptr->r_flagsr |= (RFR_RES_ALL);
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_ALL);
         return true;
     }
 
@@ -65,9 +65,9 @@ bool common_saving_throw_control(PlayerType *player_ptr, int pow, monster_type *
         return true;
 
     /* Memorize a flag */
-    if (r_ptr->flagsr & RFR_RES_ALL) {
+    if (r_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         if (is_original_ap_and_seen(player_ptr, m_ptr))
-            r_ptr->r_flagsr |= (RFR_RES_ALL);
+            r_ptr->r_resistance_flags.set(MonsterResistanceType::RESIST_ALL);
         return true;
     }
 

diff --git a/src/view/display-lore-status.cpp b/src/view/display-lore-status.cpp
index 4496b6e..056acc0 100644 (file)
--- a/src/view/display-lore-status.cpp
+++ b/src/view/display-lore-status.cpp
@@ -154,22 +154,22 @@ void display_monster_constitutions(lore_type *lore_ptr)
 
 void display_monster_concrete_weakness(lore_type *lore_ptr)
 {
-    if (lore_ptr->flags3 & RF3_HURT_ROCK) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::HURT_ROCK)) {
         lore_ptr->vp[lore_ptr->vn] = _("岩を除去するもの", "rock remover");
         lore_ptr->color[lore_ptr->vn++] = TERM_UMBER;
     }
 
-    if (lore_ptr->flags3 & RF3_HURT_LITE) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::HURT_LITE)) {
         lore_ptr->vp[lore_ptr->vn] = _("明るい光", "bright light");
         lore_ptr->color[lore_ptr->vn++] = TERM_YELLOW;
     }
 
-    if (lore_ptr->flags3 & RF3_HURT_FIRE) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::HURT_FIRE)) {
         lore_ptr->vp[lore_ptr->vn] = _("炎", "fire");
         lore_ptr->color[lore_ptr->vn++] = TERM_RED;
     }
 
-    if (lore_ptr->flags3 & RF3_HURT_COLD) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::HURT_COLD)) {
         lore_ptr->vp[lore_ptr->vn] = _("冷気", "cold");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_WHITE;
     }
@@ -201,107 +201,107 @@ void display_monster_weakness(lore_type *lore_ptr)
 
 void display_monster_concrete_resistances(lore_type *lore_ptr)
 {
-    if (lore_ptr->flagsr & RFR_IM_ACID) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_ACID)) {
         lore_ptr->vp[lore_ptr->vn] = _("酸", "acid");
         lore_ptr->color[lore_ptr->vn++] = TERM_GREEN;
     }
 
-    if (lore_ptr->flagsr & RFR_IM_ELEC) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_ELEC)) {
         lore_ptr->vp[lore_ptr->vn] = _("稲妻", "lightning");
         lore_ptr->color[lore_ptr->vn++] = TERM_BLUE;
     }
 
-    if (lore_ptr->flagsr & RFR_IM_FIRE) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_FIRE)) {
         lore_ptr->vp[lore_ptr->vn] = _("炎", "fire");
         lore_ptr->color[lore_ptr->vn++] = TERM_RED;
     }
 
-    if (lore_ptr->flagsr & RFR_IM_COLD) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_COLD)) {
         lore_ptr->vp[lore_ptr->vn] = _("冷気", "cold");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_WHITE;
     }
 
-    if (lore_ptr->flagsr & RFR_IM_POIS) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::IMMUNE_POISON)) {
         lore_ptr->vp[lore_ptr->vn] = _("毒", "poison");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_GREEN;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_LITE) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_LITE)) {
         lore_ptr->vp[lore_ptr->vn] = _("閃光", "light");
         lore_ptr->color[lore_ptr->vn++] = TERM_YELLOW;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_DARK) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_DARK)) {
         lore_ptr->vp[lore_ptr->vn] = _("暗黒", "dark");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_DARK;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_NETH) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_NETHER)) {
         lore_ptr->vp[lore_ptr->vn] = _("地獄", "nether");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_DARK;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_WATE) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_WATER)) {
         lore_ptr->vp[lore_ptr->vn] = _("水", "water");
         lore_ptr->color[lore_ptr->vn++] = TERM_BLUE;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_PLAS) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_PLASMA)) {
         lore_ptr->vp[lore_ptr->vn] = _("プラズマ", "plasma");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_RED;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_SHAR) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_SHARDS)) {
         lore_ptr->vp[lore_ptr->vn] = _("破片", "shards");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_UMBER;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_SOUN) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_SOUND)) {
         lore_ptr->vp[lore_ptr->vn] = _("轟音", "sound");
         lore_ptr->color[lore_ptr->vn++] = TERM_ORANGE;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_CHAO) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_CHAOS)) {
         lore_ptr->vp[lore_ptr->vn] = _("カオス", "chaos");
         lore_ptr->color[lore_ptr->vn++] = TERM_VIOLET;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_NEXU) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_NEXUS)) {
         lore_ptr->vp[lore_ptr->vn] = _("因果混乱", "nexus");
         lore_ptr->color[lore_ptr->vn++] = TERM_VIOLET;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_DISE) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_DISENCHANT)) {
         lore_ptr->vp[lore_ptr->vn] = _("劣化", "disenchantment");
         lore_ptr->color[lore_ptr->vn++] = TERM_VIOLET;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_WALL) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_FORCE)) {
         lore_ptr->vp[lore_ptr->vn] = _("フォース", "force");
         lore_ptr->color[lore_ptr->vn++] = TERM_UMBER;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_INER) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_INERTIA)) {
         lore_ptr->vp[lore_ptr->vn] = _("遅鈍", "inertia");
         lore_ptr->color[lore_ptr->vn++] = TERM_SLATE;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_TIME) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TIME)) {
         lore_ptr->vp[lore_ptr->vn] = _("時間逆転", "time");
         lore_ptr->color[lore_ptr->vn++] = TERM_L_BLUE;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_GRAV) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_GRAVITY)) {
         lore_ptr->vp[lore_ptr->vn] = _("重力", "gravity");
         lore_ptr->color[lore_ptr->vn++] = TERM_SLATE;
     }
 
-    if (lore_ptr->flagsr & RFR_RES_ALL) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_ALL)) {
         lore_ptr->vp[lore_ptr->vn] = _("あらゆる攻撃", "all");
         lore_ptr->color[lore_ptr->vn++] = TERM_YELLOW;
     }
 
-    if ((lore_ptr->flagsr & RFR_RES_TELE) && lore_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT) && lore_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         lore_ptr->vp[lore_ptr->vn] = _("テレポート", "teleportation");
         lore_ptr->color[lore_ptr->vn++] = TERM_ORANGE;
     }
@@ -368,7 +368,7 @@ void display_monster_concrete_immunities(lore_type *lore_ptr)
         lore_ptr->color[lore_ptr->vn++] = TERM_BLUE;
     }
 
-    if ((lore_ptr->flagsr & RFR_RES_TELE) && lore_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
+    if (lore_ptr->resistance_flags.has(MonsterResistanceType::RESIST_TELEPORT) && lore_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         lore_ptr->vp[lore_ptr->vn] = _("テレポートされない", "teleported");
         lore_ptr->color[lore_ptr->vn++] = TERM_ORANGE;
     }