[Refactor] #1951 新定義に合わせて置き換え

diff --git a/src/action/mutation-execution.cpp b/src/action/mutation-execution.cpp
index df37036..9b0a703 100644 (file)
--- a/src/action/mutation-execution.cpp
+++ b/src/action/mutation-execution.cpp
@@ -53,6 +53,7 @@
 #include "system/object-type-definition.h"
 #include "system/player-type-definition.h"
 #include "target/target-getter.h"
+#include "util/bit-flags-calculator.h"
 #include "view/display-messages.h"
 
 /*!
@@ -247,7 +248,7 @@ bool exe_mutation_power(PlayerType *player_ptr, PlayerMutationType power)
         m_ptr = &player_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
         monster_race *r_ptr;
         r_ptr = &r_info[m_ptr->r_idx];
-        if ((r_ptr->flags3 & RF3_EVIL) && !(r_ptr->flags1 & RF1_QUESTOR) && !(r_ptr->flags1 & RF1_UNIQUE) && !player_ptr->current_floor_ptr->inside_arena && !inside_quest(player_ptr->current_floor_ptr->quest_number) && (r_ptr->level < randint1(player_ptr->lev + 50)) && m_ptr->mflag2.has_not(MonsterConstantFlagType::NOGENO)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL) && none_bits(r_ptr->flags1, RF1_QUESTOR) && r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && !player_ptr->current_floor_ptr->inside_arena && !inside_quest(player_ptr->current_floor_ptr->quest_number) && (r_ptr->level < randint1(player_ptr->lev + 50)) && m_ptr->mflag2.has_not(MonsterConstantFlagType::NOGENO)) {
             if (record_named_pet && is_pet(m_ptr) && m_ptr->nickname) {
                 GAME_TEXT m_name[MAX_NLEN];
                 monster_desc(player_ptr, m_name, m_ptr, MD_INDEF_VISIBLE);

diff --git a/src/autopick/autopick-entry.cpp b/src/autopick/autopick-entry.cpp
index 62c7760..ddeec91 100644 (file)
--- a/src/autopick/autopick-entry.cpp
+++ b/src/autopick/autopick-entry.cpp
@@ -383,7 +383,7 @@ void autopick_entry_from_object(PlayerType *player_ptr, autopick_type *entry, Ob
         ADD_FLG(FLG_WANTED);
     }
 
-    if ((o_ptr->tval == ItemKindType::CORPSE || o_ptr->tval == ItemKindType::STATUE) && (r_info[o_ptr->pval].flags1 & RF1_UNIQUE)) {
+    if ((o_ptr->tval == ItemKindType::CORPSE || o_ptr->tval == ItemKindType::STATUE) && r_info[o_ptr->pval].kind_flags.has(MonsterKindType::UNIQUE)) {
         ADD_FLG(FLG_UNIQUE);
     }
 

diff --git a/src/autopick/autopick-matcher.cpp b/src/autopick/autopick-matcher.cpp
index be647fc..06f48ec 100644 (file)
--- a/src/autopick/autopick-matcher.cpp
+++ b/src/autopick/autopick-matcher.cpp
@@ -172,7 +172,7 @@ bool is_autopick_match(PlayerType *player_ptr, ObjectType *o_ptr, autopick_type
     if (IS_FLG(FLG_WANTED) && !object_is_bounty(player_ptr, o_ptr))
         return false;
 
-    if (IS_FLG(FLG_UNIQUE) && ((o_ptr->tval != ItemKindType::CORPSE && o_ptr->tval != ItemKindType::STATUE) || !(r_info[o_ptr->pval].flags1 & RF1_UNIQUE)))
+    if (IS_FLG(FLG_UNIQUE) && ((o_ptr->tval != ItemKindType::CORPSE && o_ptr->tval != ItemKindType::STATUE) || r_info[o_ptr->pval].kind_flags.has_not(MonsterKindType::UNIQUE)))
         return false;
 
     if (IS_FLG(FLG_HUMAN) && (o_ptr->tval != ItemKindType::CORPSE || !angband_strchr("pht", r_info[o_ptr->pval].d_char)))

diff --git a/src/avatar/avatar-changer.cpp b/src/avatar/avatar-changer.cpp
index 148de8e..31d5c8c 100644 (file)
--- a/src/avatar/avatar-changer.cpp
+++ b/src/avatar/avatar-changer.cpp
@@ -7,6 +7,7 @@
 #include "avatar/avatar-changer.h"
 #include "avatar/avatar.h"
 #include "dungeon/dungeon.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-ability-mask.h"
 #include "monster-race/race-flags1.h"
@@ -42,7 +43,7 @@ void AvatarChanger::change_virtue()
     }
 
     this->change_virtue_good_evil();
-    if (any_bits(r_ptr->flags3, RF3_UNDEAD) && any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::UNDEAD) && r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         chg_virtue(this->player_ptr, V_VITALITY, 2);
     }
 
@@ -89,15 +90,15 @@ void AvatarChanger::change_virtue_non_beginner()
 void AvatarChanger::change_virtue_unique()
 {
     auto *r_ptr = &r_info[m_ptr->r_idx];
-    if (none_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         return;
     }
 
-    if (any_bits(r_ptr->flags3, RF3_EVIL | RF3_GOOD)) {
+    if (r_ptr->kind_flags.has_any_of(alignment_mask)) {
         chg_virtue(this->player_ptr, V_HARMONY, 2);
     }
 
-    if (any_bits(r_ptr->flags3, RF3_GOOD)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::GOOD)) {
         chg_virtue(this->player_ptr, V_UNLIFE, 2);
         chg_virtue(this->player_ptr, V_VITALITY, -2);
     }
@@ -115,23 +116,23 @@ void AvatarChanger::change_virtue_good_evil()
 {
     auto *floor_ptr = this->player_ptr->current_floor_ptr;
     auto *r_ptr = &r_info[m_ptr->r_idx];
-    if (any_bits(r_ptr->flags3, RF3_GOOD) && ((r_ptr->level) / 10 + (3 * floor_ptr->dun_level) >= randint1(100))) {
+    if (r_ptr->kind_flags.has(MonsterKindType::GOOD) && ((r_ptr->level) / 10 + (3 * floor_ptr->dun_level) >= randint1(100))) {
         chg_virtue(this->player_ptr, V_UNLIFE, 1);
     }
 
-    if (any_bits(r_ptr->flags3, RF3_ANGEL)) {
-        if (any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::ANGEL)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             chg_virtue(this->player_ptr, V_FAITH, -2);
         } else if ((r_ptr->level) / 10 + (3 * floor_ptr->dun_level) >= randint1(100)) {
-            auto change_value = any_bits(r_ptr->flags3, RF3_GOOD) ? -1 : 1;
+            auto change_value = r_ptr->kind_flags.has(MonsterKindType::GOOD) ? -1 : 1;
             chg_virtue(this->player_ptr, V_FAITH, change_value);
         }
 
         return;
     }
 
-    if (any_bits(r_ptr->flags3, RF3_DEMON)) {
-        if (any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::DEMON)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             chg_virtue(this->player_ptr, V_FAITH, 2);
         } else if ((r_ptr->level) / 10 + (3 * floor_ptr->dun_level) >= randint1(100)) {
             chg_virtue(this->player_ptr, V_FAITH, 1);
@@ -150,7 +151,7 @@ void AvatarChanger::change_virtue_revenge()
         return;
     }
 
-    if (any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         chg_virtue(this->player_ptr, V_HONOUR, 10);
         return;
     }
@@ -184,7 +185,7 @@ void AvatarChanger::change_virtue_wild_thief()
     }
 
     if (thief) {
-        if (any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             chg_virtue(this->player_ptr, V_JUSTICE, 3);
             return;
         }
@@ -209,7 +210,7 @@ void AvatarChanger::change_virtue_good_animal()
     auto *r_ptr = &r_info[m_ptr->r_idx];
     auto magic_ability_flags = r_ptr->ability_flags;
     magic_ability_flags.reset(RF_ABILITY_NOMAGIC_MASK);
-    if (none_bits(r_ptr->flags3, RF3_ANIMAL) || any_bits(r_ptr->flags3, RF3_EVIL) || magic_ability_flags.any()) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::ANIMAL) || r_ptr->kind_flags.has(MonsterKindType::EVIL) || magic_ability_flags.any()) {
         return;
     }
 

diff --git a/src/birth/game-play-initializer.cpp b/src/birth/game-play-initializer.cpp
index f187d01..9c23c20 100644 (file)
--- a/src/birth/game-play-initializer.cpp
+++ b/src/birth/game-play-initializer.cpp
@@ -84,7 +84,7 @@ void player_wipe_without_name(PlayerType *player_ptr)
         }
         r_ref.cur_num = 0;
         r_ref.max_num = 100;
-        if (r_ref.flags1 & RF1_UNIQUE)
+        if (r_ref.kind_flags.has(MonsterKindType::UNIQUE))
             r_ref.max_num = 1;
         else if (r_ref.flags7 & RF7_NAZGUL)
             r_ref.max_num = MAX_NAZGUL_NUM;

diff --git a/src/blue-magic/blue-magic-caster.cpp b/src/blue-magic/blue-magic-caster.cpp
index a56d232..bf6036b 100644 (file)
--- a/src/blue-magic/blue-magic-caster.cpp
+++ b/src/blue-magic/blue-magic-caster.cpp
@@ -49,8 +49,7 @@ static bool cast_blue_dispel(PlayerType *player_ptr)
         return false;
 
     MONSTER_IDX m_idx = player_ptr->current_floor_ptr->grid_array[target_row][target_col].m_idx;
-    if ((m_idx == 0) || !player_has_los_bold(player_ptr, target_row, target_col)
-        || !projectable(player_ptr, player_ptr->y, player_ptr->x, target_row, target_col))
+    if ((m_idx == 0) || !player_has_los_bold(player_ptr, target_row, target_col) || !projectable(player_ptr, player_ptr->y, player_ptr->x, target_row, target_col))
         return true;
 
     dispel_monster_status(player_ptr, m_idx);
@@ -94,8 +93,7 @@ static bool exe_blue_teleport_back(PlayerType *player_ptr, GAME_TEXT *m_name)
     monster_type *m_ptr;
     monster_race *r_ptr;
     auto *floor_ptr = player_ptr->current_floor_ptr;
-    if ((floor_ptr->grid_array[target_row][target_col].m_idx == 0) || !player_has_los_bold(player_ptr, target_row, target_col)
-        || !projectable(player_ptr, player_ptr->y, player_ptr->x, target_row, target_col))
+    if ((floor_ptr->grid_array[target_row][target_col].m_idx == 0) || !player_has_los_bold(player_ptr, target_row, target_col) || !projectable(player_ptr, player_ptr->y, player_ptr->x, target_row, target_col))
         return true;
 
     m_ptr = &floor_ptr->m_list[floor_ptr->grid_array[target_row][target_col].m_idx];
@@ -104,7 +102,7 @@ static bool exe_blue_teleport_back(PlayerType *player_ptr, GAME_TEXT *m_name)
     if ((r_ptr->flagsr & RFR_RES_TELE) == 0)
         return false;
 
-    if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flagsr & RFR_RES_ALL)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flagsr & RFR_RES_ALL)) {
         if (is_original_ap_and_seen(player_ptr, m_ptr))
             r_ptr->r_flagsr |= RFR_RES_TELE;
 

diff --git a/src/cmd-action/cmd-attack.cpp b/src/cmd-action/cmd-attack.cpp
index ab49d8d..1d2953b 100644 (file)
--- a/src/cmd-action/cmd-attack.cpp
+++ b/src/cmd-action/cmd-attack.cpp
@@ -115,7 +115,7 @@ static void natural_attack(PlayerType *player_ptr, MONSTER_IDX m_idx, PlayerMuta
     int bonus = player_ptr->to_h_m + (player_ptr->lev * 6 / 5);
     int chance = (player_ptr->skill_thn + (bonus * BTH_PLUS_ADJ));
 
-    bool is_hit = ((r_ptr->flags2 & RF2_QUANTUM) == 0) || !randint0(2);
+    bool is_hit = (r_ptr->kind_flags.has_not(MonsterKindType::QUANTUM)) || !randint0(2);
     is_hit &= test_hit_norm(player_ptr, chance, r_ptr->ac, m_ptr->ml);
     if (!is_hit) {
         sound(SOUND_MISS);
@@ -243,9 +243,9 @@ bool do_cmd_attack(PlayerType *player_ptr, POSITION y, POSITION x, combat_option
     }
 
     if (monster_csleep_remaining(m_ptr)) {
-        if (!(r_ptr->flags3 & RF3_EVIL) || one_in_(5))
+        if (r_ptr->kind_flags.has_not(MonsterKindType::EVIL) || one_in_(5))
             chg_virtue(player_ptr, V_COMPASSION, -1);
-        if (!(r_ptr->flags3 & RF3_EVIL) || one_in_(5))
+        if (r_ptr->kind_flags.has_not(MonsterKindType::EVIL) || one_in_(5))
             chg_virtue(player_ptr, V_HONOUR, -1);
     }
 

diff --git a/src/cmd-action/cmd-mane.cpp b/src/cmd-action/cmd-mane.cpp
index 3a97d73..0273ba8 100644 (file)
--- a/src/cmd-action/cmd-mane.cpp
+++ b/src/cmd-action/cmd-mane.cpp
@@ -972,7 +972,7 @@ static bool use_mane(PlayerType *player_ptr, MonsterAbilityType spell)
         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->flags1 & (RF1_UNIQUE)) || (r_ptr->flagsr & RFR_RES_ALL)) {
+            if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flagsr & RFR_RES_ALL)) {
                 if (is_original_ap_and_seen(player_ptr, m_ptr)) {
                     r_ptr->r_flagsr |= RFR_RES_TELE;
                 }

diff --git a/src/cmd-action/cmd-pet.cpp b/src/cmd-action/cmd-pet.cpp
index e67ebc4..8003861 100644 (file)
--- a/src/cmd-action/cmd-pet.cpp
+++ b/src/cmd-action/cmd-pet.cpp
@@ -205,7 +205,7 @@ bool do_cmd_riding(PlayerType *player_ptr, bool force)
     x = player_ptr->x + ddx[dir];
     g_ptr = &player_ptr->current_floor_ptr->grid_array[y][x];
 
-   PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
+    PlayerClass(player_ptr).break_samurai_stance({ SamuraiStanceType::MUSOU });
 
     if (player_ptr->riding) {
         /* Skip non-empty grids */
@@ -326,7 +326,7 @@ static void do_name_pet(PlayerType *player_ptr)
             msg_print(_("そのモンスターはペットではない。", "This monster is not a pet."));
             return;
         }
-        if (r_info[m_ptr->r_idx].flags1 & RF1_UNIQUE) {
+        if (r_info[m_ptr->r_idx].kind_flags.has(MonsterKindType::UNIQUE)) {
             msg_print(_("そのモンスターの名前は変えられない！", "You cannot change the name of this monster!"));
             return;
         }
@@ -487,10 +487,7 @@ void do_cmd_pet(PlayerType *player_ptr)
     powers[num++] = PET_NAME;
 
     if (player_ptr->riding) {
-        if ((can_attack_with_main_hand(player_ptr) && (empty_hands(player_ptr, false) == EMPTY_HAND_SUB)
-                && player_ptr->inventory_list[INVEN_MAIN_HAND].allow_two_hands_wielding())
-            || (can_attack_with_sub_hand(player_ptr) && (empty_hands(player_ptr, false) == EMPTY_HAND_MAIN)
-                && player_ptr->inventory_list[INVEN_SUB_HAND].allow_two_hands_wielding())) {
+        if ((can_attack_with_main_hand(player_ptr) && (empty_hands(player_ptr, false) == EMPTY_HAND_SUB) && player_ptr->inventory_list[INVEN_MAIN_HAND].allow_two_hands_wielding()) || (can_attack_with_sub_hand(player_ptr) && (empty_hands(player_ptr, false) == EMPTY_HAND_MAIN) && player_ptr->inventory_list[INVEN_SUB_HAND].allow_two_hands_wielding())) {
             if (player_ptr->pet_extra_flags & PF_TWO_HANDS) {
                 power_desc[num] = _("武器を片手で持つ", "use one hand to control the pet you are riding");
             } else {
@@ -511,8 +508,7 @@ void do_cmd_pet(PlayerType *player_ptr)
                     }
 
                     powers[num++] = PET_TWO_HANDS;
-                } else if ((empty_hands(player_ptr, false) != EMPTY_HAND_NONE) && !has_melee_weapon(player_ptr, INVEN_MAIN_HAND)
-                    && !has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
+                } else if ((empty_hands(player_ptr, false) != EMPTY_HAND_NONE) && !has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && !has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
                     if (player_ptr->pet_extra_flags & PF_TWO_HANDS) {
                         power_desc[num] = _("格闘を行わない", "use one hand to control the pet you are riding");
                     } else {

diff --git a/src/cmd-io/cmd-lore.cpp b/src/cmd-io/cmd-lore.cpp
index bb8f7aa..a945996 100644 (file)
--- a/src/cmd-io/cmd-lore.cpp
+++ b/src/cmd-io/cmd-lore.cpp
@@ -91,10 +91,10 @@ void do_cmd_query_symbol(PlayerType *player_ptr)
         if (!cheat_know && !r_ref.r_sights)
             continue;
 
-        if (norm && (r_ref.flags1 & (RF1_UNIQUE)))
+        if (norm && r_ref.kind_flags.has(MonsterKindType::UNIQUE))
             continue;
 
-        if (uniq && !(r_ref.flags1 & (RF1_UNIQUE)))
+        if (uniq && r_ref.kind_flags.has_not(MonsterKindType::UNIQUE))
             continue;
 
         if (ride && !(r_ref.flags7 & (RF7_RIDING)))

diff --git a/src/combat/attack-criticality.cpp b/src/combat/attack-criticality.cpp
index 6719784..de7fa96 100644 (file)
--- a/src/combat/attack-criticality.cpp
+++ b/src/combat/attack-criticality.cpp
@@ -97,7 +97,7 @@ static void ninja_critical(PlayerType *player_ptr, player_attack_type *pa_ptr)
     }
 
     bool is_weaken = pa_ptr->m_ptr->hp < maxhp / 2;
-    bool is_unique = ((r_ptr->flags1 & RF1_UNIQUE) != 0) || ((r_ptr->flags7 & RF7_UNIQUE2) != 0);
+    bool is_unique = (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) || ((r_ptr->flags7 & RF7_UNIQUE2) != 0);
     bool is_critical = (is_weaken && one_in_((player_ptr->num_blow[0] + player_ptr->num_blow[1] + 1) * 10)) || ((one_in_(666) || ((pa_ptr->backstab || pa_ptr->surprise_attack) && one_in_(11))) && !is_unique);
     if (!is_critical)
         return;
@@ -122,7 +122,7 @@ void critical_attack(PlayerType *player_ptr, player_attack_type *pa_ptr)
     auto *o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + pa_ptr->hand];
     auto *r_ptr = &r_info[pa_ptr->m_ptr->r_idx];
     if (((o_ptr->tval == ItemKindType::SWORD) && (o_ptr->sval == SV_POISON_NEEDLE)) || (pa_ptr->mode == HISSATSU_KYUSHO)) {
-        if ((randint1(randint1(r_ptr->level / 7) + 5) == 1) && !(r_ptr->flags1 & RF1_UNIQUE) && !(r_ptr->flags7 & RF7_UNIQUE2)) {
+        if ((randint1(randint1(r_ptr->level / 7) + 5) == 1) && r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && !(r_ptr->flags7 & RF7_UNIQUE2)) {
             pa_ptr->attack_damage = pa_ptr->m_ptr->hp + 1;
             msg_format(_("%sの急所を突き刺した！", "You hit %s on a fatal spot!"), pa_ptr->m_name);
         } else

diff --git a/src/combat/aura-counterattack.cpp b/src/combat/aura-counterattack.cpp
index c167cfe..23f7cd1 100644 (file)
--- a/src/combat/aura-counterattack.cpp
+++ b/src/combat/aura-counterattack.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief モンスターから直接攻撃を受けた時に、プレイヤーのオーラダメージで反撃する処理
  * @date 2020/05/31
  * @author Hourier
@@ -129,7 +129,7 @@ static void aura_holy_by_monster_attack(PlayerType *player_ptr, MonsterAttackPla
         return;
 
     auto *r_ptr = &r_info[monap_ptr->m_ptr->r_idx];
-    if ((r_ptr->flags3 & RF3_EVIL) == 0)
+    if (r_ptr->kind_flags.has_not(MonsterKindType::EVIL))
         return;
 
     if ((r_ptr->flagsr & RFR_RES_ALL) != 0) {
@@ -149,7 +149,7 @@ static void aura_holy_by_monster_attack(PlayerType *player_ptr, MonsterAttackPla
     }
 
     if (is_original_ap_and_seen(player_ptr, monap_ptr->m_ptr))
-        r_ptr->r_flags3 |= RF3_EVIL;
+        r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
 }
 
 static void aura_force_by_monster_attack(PlayerType *player_ptr, MonsterAttackPlayer *monap_ptr)

diff --git a/src/combat/shoot.cpp b/src/combat/shoot.cpp
index e3633fb..09add0b 100644 (file)
--- a/src/combat/shoot.cpp
+++ b/src/combat/shoot.cpp
@@ -1,4 +1,4 @@
-#include "combat/shoot.h"
+#include "combat/shoot.h"
 #include "artifact/fixed-art-types.h"
 #include "avatar/avatar.h"
 #include "combat/attack-criticality.h"
@@ -163,162 +163,162 @@ static MULTIPLY calc_shot_damage_with_slay(
     case ItemKindType::SHOT:
     case ItemKindType::ARROW:
     case ItemKindType::BOLT: {
-        if ((flags.has(TR_SLAY_ANIMAL)) && any_bits(race_ptr->flags3, RF3_ANIMAL)) {
+        if ((flags.has(TR_SLAY_ANIMAL)) && race_ptr->kind_flags.has(MonsterKindType::ANIMAL)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_ANIMAL);
+                race_ptr->r_kind_flags.set(MonsterKindType::ANIMAL);
             }
             if (mult < 17)
                 mult = 17;
         }
 
-        if ((flags.has(TR_KILL_ANIMAL)) && any_bits(race_ptr->flags3, RF3_ANIMAL)) {
+        if ((flags.has(TR_KILL_ANIMAL)) && race_ptr->kind_flags.has(MonsterKindType::ANIMAL)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_ANIMAL);
+                race_ptr->r_kind_flags.set(MonsterKindType::ANIMAL);
             }
             if (mult < 27)
                 mult = 27;
         }
 
-        if ((flags.has(TR_SLAY_EVIL)) && any_bits(race_ptr->flags3, RF3_EVIL)) {
+        if ((flags.has(TR_SLAY_EVIL)) && race_ptr->kind_flags.has(MonsterKindType::EVIL)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_EVIL);
+                race_ptr->r_kind_flags.set(MonsterKindType::EVIL);
             }
             if (mult < 15)
                 mult = 15;
         }
 
-        if ((flags.has(TR_KILL_EVIL)) && any_bits(race_ptr->flags3, RF3_EVIL)) {
+        if ((flags.has(TR_KILL_EVIL)) && race_ptr->kind_flags.has(MonsterKindType::EVIL)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_EVIL);
+                race_ptr->r_kind_flags.set(MonsterKindType::EVIL);
             }
             if (mult < 25)
                 mult = 25;
         }
 
-        if ((flags.has(TR_SLAY_GOOD)) && any_bits(race_ptr->flags3, RF3_GOOD)) {
+        if ((flags.has(TR_SLAY_GOOD)) && race_ptr->kind_flags.has(MonsterKindType::GOOD)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_GOOD);
+                race_ptr->r_kind_flags.set(MonsterKindType::GOOD);
             }
             if (mult < 15)
                 mult = 15;
         }
 
-        if ((flags.has(TR_KILL_GOOD)) && any_bits(race_ptr->flags3, RF3_GOOD)) {
+        if ((flags.has(TR_KILL_GOOD)) && race_ptr->kind_flags.has(MonsterKindType::GOOD)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_GOOD);
+                race_ptr->r_kind_flags.set(MonsterKindType::GOOD);
             }
             if (mult < 25)
                 mult = 25;
         }
 
-        if ((flags.has(TR_SLAY_HUMAN)) && any_bits(race_ptr->flags2, RF2_HUMAN)) {
+        if ((flags.has(TR_SLAY_HUMAN)) && race_ptr->kind_flags.has(MonsterKindType::HUMAN)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags2, RF2_HUMAN);
+                race_ptr->r_kind_flags.set(MonsterKindType::HUMAN);
             }
             if (mult < 17)
                 mult = 17;
         }
 
-        if ((flags.has(TR_KILL_HUMAN)) && any_bits(race_ptr->flags2, RF2_HUMAN)) {
+        if ((flags.has(TR_KILL_HUMAN)) && race_ptr->kind_flags.has(MonsterKindType::HUMAN)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags2, RF2_HUMAN);
+                race_ptr->r_kind_flags.set(MonsterKindType::HUMAN);
             }
             if (mult < 27)
                 mult = 27;
         }
 
-        if ((flags.has(TR_SLAY_UNDEAD)) && any_bits(race_ptr->flags3, RF3_UNDEAD)) {
+        if ((flags.has(TR_SLAY_UNDEAD)) && race_ptr->kind_flags.has(MonsterKindType::UNDEAD)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_UNDEAD);
+                race_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
             }
             if (mult < 20)
                 mult = 20;
         }
 
-        if ((flags.has(TR_KILL_UNDEAD)) && any_bits(race_ptr->flags3, RF3_UNDEAD)) {
+        if ((flags.has(TR_KILL_UNDEAD)) && race_ptr->kind_flags.has(MonsterKindType::UNDEAD)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_UNDEAD);
+                race_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
             }
             if (mult < 30)
                 mult = 30;
         }
 
-        if ((flags.has(TR_SLAY_DEMON)) && any_bits(race_ptr->flags3, RF3_DEMON)) {
+        if ((flags.has(TR_SLAY_DEMON)) && race_ptr->kind_flags.has(MonsterKindType::DEMON)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_DEMON);
+                race_ptr->r_kind_flags.set(MonsterKindType::DEMON);
             }
             if (mult < 20)
                 mult = 20;
         }
 
-        if ((flags.has(TR_KILL_DEMON)) && any_bits(race_ptr->flags3, RF3_DEMON)) {
+        if ((flags.has(TR_KILL_DEMON)) && race_ptr->kind_flags.has(MonsterKindType::DEMON)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_DEMON);
+                race_ptr->r_kind_flags.set(MonsterKindType::DEMON);
             }
             if (mult < 30)
                 mult = 30;
         }
 
-        if ((flags.has(TR_SLAY_ORC)) && any_bits(race_ptr->flags3, RF3_ORC)) {
+        if ((flags.has(TR_SLAY_ORC)) && race_ptr->kind_flags.has(MonsterKindType::ORC)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_ORC);
+                race_ptr->r_kind_flags.set(MonsterKindType::ORC);
             }
             if (mult < 20)
                 mult = 20;
         }
 
-        if ((flags.has(TR_KILL_ORC)) && any_bits(race_ptr->flags3, RF3_ORC)) {
+        if ((flags.has(TR_KILL_ORC)) && race_ptr->kind_flags.has(MonsterKindType::ORC)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_ORC);
+                race_ptr->r_kind_flags.set(MonsterKindType::ORC);
             }
             if (mult < 30)
                 mult = 30;
         }
 
-        if ((flags.has(TR_SLAY_TROLL)) && any_bits(race_ptr->flags3, RF3_TROLL)) {
+        if ((flags.has(TR_SLAY_TROLL)) && race_ptr->kind_flags.has(MonsterKindType::TROLL)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_TROLL);
+                race_ptr->r_kind_flags.set(MonsterKindType::TROLL);
             }
 
             if (mult < 20)
                 mult = 20;
         }
 
-        if ((flags.has(TR_KILL_TROLL)) && any_bits(race_ptr->flags3, RF3_TROLL)) {
+        if ((flags.has(TR_KILL_TROLL)) && race_ptr->kind_flags.has(MonsterKindType::TROLL)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_TROLL);
+                race_ptr->r_kind_flags.set(MonsterKindType::TROLL);
             }
             if (mult < 30)
                 mult = 30;
         }
 
-        if ((flags.has(TR_SLAY_GIANT)) && any_bits(race_ptr->flags3, RF3_GIANT)) {
+        if ((flags.has(TR_SLAY_GIANT)) && race_ptr->kind_flags.has(MonsterKindType::GIANT)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_GIANT);
+                race_ptr->r_kind_flags.set(MonsterKindType::GIANT);
             }
             if (mult < 20)
                 mult = 20;
         }
 
-        if ((flags.has(TR_KILL_GIANT)) && any_bits(race_ptr->flags3, RF3_GIANT)) {
+        if ((flags.has(TR_KILL_GIANT)) && race_ptr->kind_flags.has(MonsterKindType::GIANT)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_GIANT);
+                race_ptr->r_kind_flags.set(MonsterKindType::GIANT);
             }
             if (mult < 30)
                 mult = 30;
         }
 
-        if ((flags.has(TR_SLAY_DRAGON)) && any_bits(race_ptr->flags3, RF3_DRAGON)) {
+        if ((flags.has(TR_SLAY_DRAGON)) && race_ptr->kind_flags.has(MonsterKindType::DRAGON)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_DRAGON);
+                race_ptr->r_kind_flags.set(MonsterKindType::DRAGON);
             }
             if (mult < 20)
                 mult = 20;
         }
 
-        if ((flags.has(TR_KILL_DRAGON)) && any_bits(race_ptr->flags3, RF3_DRAGON)) {
+        if ((flags.has(TR_KILL_DRAGON)) && race_ptr->kind_flags.has(MonsterKindType::DRAGON)) {
             if (is_original_ap_and_seen(player_ptr, monster_ptr)) {
-                set_bits(race_ptr->r_flags3, RF3_DRAGON);
+                race_ptr->r_kind_flags.set(MonsterKindType::DRAGON);
             }
             if (mult < 30)
                 mult = 30;
@@ -699,9 +699,9 @@ void exe_fire(PlayerType *player_ptr, INVENTORY_IDX item, ObjectType *j_ptr, SPE
                 hit_body = true;
 
                 if (monster_csleep_remaining(m_ptr)) {
-                    if (none_bits(r_ptr->flags3, RF3_EVIL) || one_in_(5))
+                    if (r_ptr->kind_flags.has_not(MonsterKindType::EVIL) || one_in_(5))
                         chg_virtue(player_ptr, V_COMPASSION, -1);
-                    if (none_bits(r_ptr->flags3, RF3_EVIL) || one_in_(5))
+                    if (r_ptr->kind_flags.has_not(MonsterKindType::EVIL) || one_in_(5))
                         chg_virtue(player_ptr, V_HONOUR, -1);
                 }
 
@@ -745,8 +745,7 @@ void exe_fire(PlayerType *player_ptr, INVENTORY_IDX item, ObjectType *j_ptr, SPE
                     }
 
                     if (snipe_type == SP_NEEDLE) {
-                        if ((randint1(randint1(r_ptr->level / (3 + sniper_concent)) + (8 - sniper_concent)) == 1)
-                            && none_bits(r_ptr->flags1, RF1_UNIQUE) && none_bits(r_ptr->flags7, RF7_UNIQUE2)) {
+                        if ((randint1(randint1(r_ptr->level / (3 + sniper_concent)) + (8 - sniper_concent)) == 1) && r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && none_bits(r_ptr->flags7, RF7_UNIQUE2)) {
                             GAME_TEXT m_name[MAX_NLEN];
 
                             /* Get "the monster" or "it" */

diff --git a/src/dungeon/dungeon-processor.cpp b/src/dungeon/dungeon-processor.cpp
index 9448725..5af253a 100644 (file)
--- a/src/dungeon/dungeon-processor.cpp
+++ b/src/dungeon/dungeon-processor.cpp
@@ -217,7 +217,7 @@ void process_dungeon(PlayerType *player_ptr, bool load_game)
             wild_regen--;
     }
 
-    if ((inside_quest(quest_num)) && none_bits(r_info[quest[enum2i(quest_num)].r_idx].flags1, RF1_UNIQUE)) {
+    if ((inside_quest(quest_num)) && r_info[quest[enum2i(quest_num)].r_idx].kind_flags.has_not(MonsterKindType::UNIQUE)) {
         r_info[quest[enum2i(quest_num)].r_idx].flags1 &= ~RF1_QUESTOR;
     }
 

diff --git a/src/dungeon/quest-monster-placer.cpp b/src/dungeon/quest-monster-placer.cpp
index 0f5692e..fa0a093 100644 (file)
--- a/src/dungeon/quest-monster-placer.cpp
+++ b/src/dungeon/quest-monster-placer.cpp
@@ -1,4 +1,4 @@
-#include "dungeon/quest-monster-placer.h"
+#include "dungeon/quest-monster-placer.h"
 #include "dungeon/quest.h"
 #include "floor/floor-generator-util.h"
 #include "floor/geometry.h"
@@ -31,7 +31,7 @@ bool place_quest_monsters(PlayerType *player_ptr)
         }
 
         r_ptr = &r_info[quest[i].r_idx];
-        if ((r_ptr->flags1 & RF1_UNIQUE) && (r_ptr->cur_num >= r_ptr->max_num))
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) && (r_ptr->cur_num >= r_ptr->max_num))
             continue;
 
         mode = PM_NO_KAGE | PM_NO_PET;
@@ -51,7 +51,7 @@ bool place_quest_monsters(PlayerType *player_ptr)
                     x = randint0(floor_ptr->width);
                     g_ptr = &floor_ptr->grid_array[y][x];
                     f_ptr = &f_info[g_ptr->feat];
-                    if (f_ptr->flags.has_none_of({FloorFeatureType::MOVE, FloorFeatureType::CAN_FLY}))
+                    if (f_ptr->flags.has_none_of({ FloorFeatureType::MOVE, FloorFeatureType::CAN_FLY }))
                         continue;
 
                     if (!monster_can_enter(player_ptr, y, x, r_ptr, 0))

diff --git a/src/dungeon/quest.cpp b/src/dungeon/quest.cpp
index 44fb069..aa3ecb5 100644 (file)
--- a/src/dungeon/quest.cpp
+++ b/src/dungeon/quest.cpp
@@ -80,7 +80,7 @@ void determine_random_questor(PlayerType *player_ptr, quest_type *q_ptr)
         monster_race *r_ptr;
         r_ptr = &r_info[r_idx];
 
-        if (!(r_ptr->flags1 & RF1_UNIQUE))
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
             continue;
         if (r_ptr->flags8 & RF8_NO_QUEST)
             continue;
@@ -196,7 +196,7 @@ void quest_discovery(QuestId q_idx)
         return;
     }
 
-    bool is_random_quest_skipped = (r_ptr->flags1 & RF1_UNIQUE) != 0;
+    bool is_random_quest_skipped = r_ptr->kind_flags.has(MonsterKindType::UNIQUE);
     is_random_quest_skipped &= r_ptr->max_num == 0;
     if (!is_random_quest_skipped) {
         msg_format(_("注意せよ！この階は%sによって守られている！", "Beware, this level is protected by %s!"), name);

diff --git a/src/effect/effect-monster-charm.cpp b/src/effect/effect-monster-charm.cpp
index 7f55fcc..9e8a07f 100644 (file)
--- a/src/effect/effect-monster-charm.cpp
+++ b/src/effect/effect-monster-charm.cpp
@@ -4,6 +4,7 @@
 #include "effect/effect-monster-util.h"
 #include "effect/spells-effect-util.h"
 #include "monster-floor/monster-remover.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race-hook.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags1.h"
@@ -47,7 +48,7 @@ static void effect_monster_charm_resist(PlayerType *player_ptr, effect_monster_t
         set_pet(player_ptr, em_ptr->m_ptr);
 
         chg_virtue(player_ptr, V_INDIVIDUALISM, -1);
-        if (em_ptr->r_ptr->flags3 & RF3_ANIMAL)
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::ANIMAL))
             chg_virtue(player_ptr, V_NATURE, 1);
     }
 }
@@ -87,7 +88,7 @@ process_result effect_monster_control_undead(PlayerType *player_ptr, effect_mons
         em_ptr->dam -= player_ptr->virtues[vir - 1] / 20;
     }
 
-    if (common_saving_throw_control(player_ptr, em_ptr->dam, em_ptr->m_ptr) || !(em_ptr->r_ptr->flags3 & RF3_UNDEAD)) {
+    if (common_saving_throw_control(player_ptr, em_ptr->dam, em_ptr->m_ptr) || em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD)) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->obvious = false;
         if (one_in_(4))
@@ -120,7 +121,7 @@ process_result effect_monster_control_demon(PlayerType *player_ptr, effect_monst
         em_ptr->dam -= player_ptr->virtues[vir - 1] / 20;
     }
 
-    if (common_saving_throw_control(player_ptr, em_ptr->dam, em_ptr->m_ptr) || !(em_ptr->r_ptr->flags3 & RF3_DEMON)) {
+    if (common_saving_throw_control(player_ptr, em_ptr->dam, em_ptr->m_ptr) || em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::DEMON)) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->obvious = false;
         if (one_in_(4))
@@ -153,7 +154,7 @@ process_result effect_monster_control_animal(PlayerType *player_ptr, effect_mons
         em_ptr->dam -= player_ptr->virtues[vir - 1] / 20;
     }
 
-    if (common_saving_throw_control(player_ptr, em_ptr->dam, em_ptr->m_ptr) || !(em_ptr->r_ptr->flags3 & RF3_ANIMAL)) {
+    if (common_saving_throw_control(player_ptr, em_ptr->dam, em_ptr->m_ptr) || em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::ANIMAL)) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->obvious = false;
         if (one_in_(4))
@@ -165,7 +166,7 @@ process_result effect_monster_control_animal(PlayerType *player_ptr, effect_mons
     } else {
         em_ptr->note = _("はなついた。", " is tamed!");
         set_pet(player_ptr, em_ptr->m_ptr);
-        if (em_ptr->r_ptr->flags3 & RF3_ANIMAL)
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::ANIMAL))
             chg_virtue(player_ptr, V_NATURE, 1);
     }
 
@@ -203,7 +204,7 @@ process_result effect_monster_charm_living(PlayerType *player_ptr, effect_monste
     } else {
         em_ptr->note = _("を支配した。", " is tamed!");
         set_pet(player_ptr, em_ptr->m_ptr);
-        if (em_ptr->r_ptr->flags3 & RF3_ANIMAL)
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::ANIMAL))
             chg_virtue(player_ptr, V_NATURE, 1);
     }
 
@@ -235,7 +236,7 @@ static void effect_monster_domination_corrupted_addition(PlayerType *player_ptr,
 // Powerful demons & undead can turn a mindcrafter's attacks back on them.
 static void effect_monster_domination_corrupted(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    bool is_corrupted = ((em_ptr->r_ptr->flags3 & (RF3_UNDEAD | RF3_DEMON)) != 0) && (em_ptr->r_ptr->level > player_ptr->lev / 2) && (one_in_(2));
+    bool is_corrupted = em_ptr->r_ptr->kind_flags.has_any_of(has_corrupted_mind) && (em_ptr->r_ptr->level > player_ptr->lev / 2) && (one_in_(2));
     if (!is_corrupted) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->obvious = false;
@@ -276,7 +277,7 @@ process_result effect_monster_domination(PlayerType *player_ptr, effect_monster_
     if (em_ptr->seen)
         em_ptr->obvious = true;
 
-    if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags1, RF1_QUESTOR) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         if (((em_ptr->r_ptr->flags3 & RF3_NO_CONF) != 0) && is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
             em_ptr->r_ptr->r_flags3 |= (RF3_NO_CONF);
 
@@ -300,7 +301,7 @@ process_result effect_monster_domination(PlayerType *player_ptr, effect_monster_
 
 static bool effect_monster_crusade_domination(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if (((em_ptr->r_ptr->flags3 & RF3_GOOD) == 0) || player_ptr->current_floor_ptr->inside_arena)
+    if ((em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::GOOD)) || player_ptr->current_floor_ptr->inside_arena)
         return false;
 
     if (em_ptr->r_ptr->flags3 & RF3_NO_CONF)
@@ -314,7 +315,7 @@ static bool effect_monster_crusade_domination(PlayerType *player_ptr, effect_mon
         return true;
     }
 
-    if ((em_ptr->r_ptr->flags1 & RF1_QUESTOR) || (em_ptr->r_ptr->flags1 & RF1_UNIQUE) || em_ptr->m_ptr->mflag2.has(MonsterConstantFlagType::NOPET) || has_aggravate(player_ptr) || ((em_ptr->r_ptr->level + 10) > randint1(em_ptr->dam))) {
+    if (any_bits(em_ptr->r_ptr->flags1, RF1_QUESTOR) || em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || em_ptr->m_ptr->mflag2.has(MonsterConstantFlagType::NOPET) || has_aggravate(player_ptr) || ((em_ptr->r_ptr->level + 10) > randint1(em_ptr->dam))) {
         if (one_in_(4))
             em_ptr->m_ptr->mflag2.set(MonsterConstantFlagType::NOPET);
 
@@ -325,7 +326,7 @@ static bool effect_monster_crusade_domination(PlayerType *player_ptr, effect_mon
     set_pet(player_ptr, em_ptr->m_ptr);
     (void)set_monster_fast(player_ptr, em_ptr->g_ptr->m_idx, monster_fast_remaining(em_ptr->m_ptr) + 100);
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
-        em_ptr->r_ptr->r_flags3 |= RF3_GOOD;
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::GOOD);
 
     return true;
 }
@@ -399,7 +400,7 @@ static void effect_monster_captured(PlayerType *player_ptr, effect_monster_type
 process_result effect_monster_capture(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
     auto *floor_ptr = player_ptr->current_floor_ptr;
-    if ((inside_quest(floor_ptr->quest_number) && (quest[enum2i(floor_ptr->quest_number)].type == QuestKindType::KILL_ALL) && !is_pet(em_ptr->m_ptr)) || any_bits(em_ptr->r_ptr->flags1, RF1_UNIQUE | RF1_QUESTOR) || any_bits(em_ptr->r_ptr->flags7, RF7_NAZGUL | RF7_UNIQUE2) || em_ptr->m_ptr->parent_m_idx) {
+    if ((inside_quest(floor_ptr->quest_number) && (quest[enum2i(floor_ptr->quest_number)].type == QuestKindType::KILL_ALL) && !is_pet(em_ptr->m_ptr)) || em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags1, RF1_QUESTOR) || any_bits(em_ptr->r_ptr->flags7, RF7_NAZGUL | RF7_UNIQUE2) || em_ptr->m_ptr->parent_m_idx) {
         msg_format(_("%sには効果がなかった。", "%s is unaffected."), em_ptr->m_name);
         em_ptr->skipped = true;
         return PROCESS_CONTINUE;

diff --git a/src/effect/effect-monster-evil.cpp b/src/effect/effect-monster-evil.cpp
index 67035ea..09c932b 100644 (file)
--- a/src/effect/effect-monster-evil.cpp
+++ b/src/effect/effect-monster-evil.cpp
@@ -1,4 +1,4 @@
-#include "effect/effect-monster-evil.h"
+#include "effect/effect-monster-evil.h"
 #include "effect/effect-monster-util.h"
 #include "monster-race/monster-race-hook.h"
 #include "monster-race/monster-race.h"
@@ -14,12 +14,12 @@ static bool effect_monster_away_resist(PlayerType *player_ptr, effect_monster_ty
 {
        if ((em_ptr->r_ptr->flagsr & RFR_RES_TELE) == 0) return false;
 
-       if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) || (em_ptr->r_ptr->flagsr & RFR_RES_ALL))
-       {
-               if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) em_ptr->r_ptr->r_flagsr |= RFR_RES_TELE;
-               em_ptr->note = _("には効果がなかった。", " is unaffected.");
-               return true;
-       }
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->flagsr & RFR_RES_ALL)) {
+        if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+            em_ptr->r_ptr->r_flagsr |= RFR_RES_TELE;
+        em_ptr->note = _("には効果がなかった。", " is unaffected.");
+        return true;
+    }
 
        if (em_ptr->r_ptr->level > randint1(100))
        {
@@ -34,19 +34,18 @@ static bool effect_monster_away_resist(PlayerType *player_ptr, effect_monster_ty
 
 process_result effect_monster_away_undead(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_UNDEAD)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
-
-       bool resists_tele = effect_monster_away_resist(player_ptr, em_ptr);
-       if (!resists_tele)
-       {
-               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_UNDEAD);
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD)) {
+        em_ptr->skipped = true;
+        em_ptr->dam = 0;
+        return PROCESS_CONTINUE;
+    }
+
+    bool resists_tele = effect_monster_away_resist(player_ptr, em_ptr);
+    if (!resists_tele) {
+        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_kind_flags.set(MonsterKindType::UNDEAD);
 
                em_ptr->do_dist = em_ptr->dam;
        }
@@ -58,19 +57,18 @@ process_result effect_monster_away_undead(PlayerType *player_ptr, effect_monster
 
 process_result effect_monster_away_evil(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_EVIL)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
-
-       bool resists_tele = effect_monster_away_resist(player_ptr, em_ptr);
-       if (!resists_tele)
-       {
-               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_EVIL);
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL)) {
+        em_ptr->skipped = true;
+        em_ptr->dam = 0;
+        return PROCESS_CONTINUE;
+    }
+
+    bool resists_tele = effect_monster_away_resist(player_ptr, em_ptr);
+    if (!resists_tele) {
+        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_kind_flags.set(MonsterKindType::EVIL);
 
                em_ptr->do_dist = em_ptr->dam;
        }
@@ -97,16 +95,16 @@ process_result effect_monster_away_all(PlayerType *player_ptr, effect_monster_ty
 
 process_result effect_monster_turn_undead(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_UNDEAD)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD)) {
+        em_ptr->skipped = true;
+        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_UNDEAD);
+    if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
 
        em_ptr->do_fear = damroll(3, (em_ptr->dam / 2)) + 1;
        if (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)
@@ -123,16 +121,16 @@ process_result effect_monster_turn_undead(PlayerType *player_ptr, effect_monster
 
 process_result effect_monster_turn_evil(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_EVIL)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL)) {
+        em_ptr->skipped = true;
+        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_EVIL);
+    if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
 
        em_ptr->do_fear = damroll(3, (em_ptr->dam / 2)) + 1;
        if (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)
@@ -152,14 +150,13 @@ process_result effect_monster_turn_all(effect_monster_type *em_ptr)
        if (em_ptr->seen) em_ptr->obvious = true;
 
        em_ptr->do_fear = damroll(3, (em_ptr->dam / 2)) + 1;
-       if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) ||
-               (em_ptr->r_ptr->flags3 & (RF3_NO_FEAR)) ||
-               (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10))
-       {
-               em_ptr->note = _("には効果がなかった。", " is unaffected.");
-               em_ptr->obvious = false;
-               em_ptr->do_fear = 0;
-       }
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) ||
+        (em_ptr->r_ptr->flags3 & (RF3_NO_FEAR)) ||
+        (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+        em_ptr->note = _("には効果がなかった。", " is unaffected.");
+        em_ptr->obvious = false;
+        em_ptr->do_fear = 0;
+    }
 
        em_ptr->dam = 0;
        return PROCESS_CONTINUE;
@@ -168,17 +165,16 @@ process_result effect_monster_turn_all(effect_monster_type *em_ptr)
 
 process_result effect_monster_disp_undead(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_UNDEAD)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD)) {
+        em_ptr->skipped = true;
+        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_UNDEAD);
+    if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
 
        em_ptr->note = _("は身震いした。", " shudders.");
        em_ptr->note_dies = _("はドロドロに溶けた！", " dissolves!");
@@ -188,16 +184,16 @@ process_result effect_monster_disp_undead(PlayerType *player_ptr, effect_monster
 
 process_result effect_monster_disp_evil(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_EVIL)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL)) {
+        em_ptr->skipped = true;
+        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_EVIL);
+    if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
 
        em_ptr->note = _("は身震いした。", " shudders.");
        em_ptr->note_dies = _("はドロドロに溶けた！", " dissolves!");
@@ -207,16 +203,16 @@ process_result effect_monster_disp_evil(PlayerType *player_ptr, effect_monster_t
 
 process_result effect_monster_disp_good(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_GOOD)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::GOOD)) {
+        em_ptr->skipped = true;
+        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_GOOD);
+    if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::GOOD);
 
        em_ptr->note = _("は身震いした。", " shudders.");
        em_ptr->note_dies = _("はドロドロに溶けた！", " dissolves!");
@@ -243,16 +239,16 @@ process_result effect_monster_disp_living(effect_monster_type *em_ptr)
 
 process_result effect_monster_disp_demon(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-       if ((em_ptr->r_ptr->flags3 & (RF3_DEMON)) == 0)
-       {
-               em_ptr->skipped = true;
-               em_ptr->dam = 0;
-               return PROCESS_CONTINUE;
-       }
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::DEMON)) {
+        em_ptr->skipped = true;
+        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_DEMON);
+    if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::DEMON);
 
        em_ptr->note = _("は身震いした。", " shudders.");
        em_ptr->note_dies = _("はドロドロに溶けた！", " dissolves!");

diff --git a/src/effect/effect-monster-oldies.cpp b/src/effect/effect-monster-oldies.cpp
index 747e473..d49df3c 100644 (file)
--- a/src/effect/effect-monster-oldies.cpp
+++ b/src/effect/effect-monster-oldies.cpp
@@ -1,4 +1,4 @@
-#include "effect/effect-monster-oldies.h"
+#include "effect/effect-monster-oldies.h"
 #include "avatar/avatar.h"
 #include "core/player-redraw-types.h"
 #include "effect/effect-monster-util.h"
@@ -16,6 +16,7 @@
 #include "system/monster-race-definition.h"
 #include "system/monster-type-definition.h"
 #include "system/player-type-definition.h"
+#include "util/bit-flags-calculator.h"
 #include "view/display-messages.h"
 
 // Powerful monsters can resist.
@@ -25,8 +26,7 @@ process_result effect_monster_old_poly(effect_monster_type *em_ptr)
         em_ptr->obvious = true;
     em_ptr->do_polymorph = true;
 
-    if ((em_ptr->r_ptr->flags1 & RF1_UNIQUE) || (em_ptr->r_ptr->flags1 & RF1_QUESTOR)
-        || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags1, RF1_QUESTOR) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->do_polymorph = false;
         em_ptr->obvious = false;
@@ -41,8 +41,7 @@ process_result effect_monster_old_clone(PlayerType *player_ptr, effect_monster_t
     if (em_ptr->seen)
         em_ptr->obvious = true;
 
-    if ((player_ptr->current_floor_ptr->inside_arena) || is_pet(em_ptr->m_ptr) || (em_ptr->r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR))
-        || (em_ptr->r_ptr->flags7 & (RF7_NAZGUL | RF7_UNIQUE2))) {
+    if ((player_ptr->current_floor_ptr->inside_arena) || is_pet(em_ptr->m_ptr) || em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags1, RF1_QUESTOR) || (em_ptr->r_ptr->flags7 & (RF7_NAZGUL | RF7_UNIQUE2))) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->dam = 0;
         return PROCESS_CONTINUE;
@@ -89,19 +88,19 @@ static void effect_monster_old_heal_check_player(PlayerType *player_ptr, effect_
         return;
 
     chg_virtue(player_ptr, V_VITALITY, 1);
-    if (em_ptr->r_ptr->flags1 & RF1_UNIQUE)
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         chg_virtue(player_ptr, V_INDIVIDUALISM, 1);
 
     if (is_friendly(em_ptr->m_ptr))
         chg_virtue(player_ptr, V_HONOUR, 1);
-    else if (!(em_ptr->r_ptr->flags3 & RF3_EVIL)) {
-        if (em_ptr->r_ptr->flags3 & RF3_GOOD)
+    else if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL)) {
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::GOOD))
             chg_virtue(player_ptr, V_COMPASSION, 2);
         else
             chg_virtue(player_ptr, V_COMPASSION, 1);
     }
 
-    if (em_ptr->r_ptr->flags3 & RF3_ANIMAL)
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::ANIMAL))
         chg_virtue(player_ptr, V_NATURE, 1);
 }
 
@@ -169,7 +168,7 @@ process_result effect_monster_old_speed(PlayerType *player_ptr, effect_monster_t
     }
 
     if (!em_ptr->who) {
-        if (em_ptr->r_ptr->flags1 & RF1_UNIQUE)
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
             chg_virtue(player_ptr, V_INDIVIDUALISM, 1);
         if (is_friendly(em_ptr->m_ptr))
             chg_virtue(player_ptr, V_HONOUR, 1);
@@ -185,7 +184,7 @@ process_result effect_monster_old_slow(PlayerType *player_ptr, effect_monster_ty
         em_ptr->obvious = true;
 
     /* Powerful monsters can resist */
-    if ((em_ptr->r_ptr->flags1 & RF1_UNIQUE) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->obvious = false;
         em_ptr->dam = 0;
@@ -208,8 +207,7 @@ process_result effect_monster_old_sleep(PlayerType *player_ptr, effect_monster_t
     if (em_ptr->seen)
         em_ptr->obvious = true;
 
-    if ((em_ptr->r_ptr->flags1 & RF1_UNIQUE) || (em_ptr->r_ptr->flags3 & RF3_NO_SLEEP)
-        || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->flags3 & RF3_NO_SLEEP) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         if (em_ptr->r_ptr->flags3 & RF3_NO_SLEEP) {
             if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
                 em_ptr->r_ptr->r_flags3 |= (RF3_NO_SLEEP);
@@ -236,8 +234,7 @@ process_result effect_monster_old_conf(PlayerType *player_ptr, effect_monster_ty
         em_ptr->obvious = true;
 
     em_ptr->do_conf = damroll(3, (em_ptr->dam / 2)) + 1;
-    if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) || (em_ptr->r_ptr->flags3 & (RF3_NO_CONF))
-        || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->flags3 & (RF3_NO_CONF)) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         if (em_ptr->r_ptr->flags3 & (RF3_NO_CONF)) {
             if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
                 em_ptr->r_ptr->r_flags3 |= (RF3_NO_CONF);
@@ -258,10 +255,10 @@ process_result effect_monster_stasis(effect_monster_type *em_ptr, bool to_evil)
         em_ptr->obvious = true;
 
     int stasis_damage = (em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10);
-    bool has_resistance = (em_ptr->r_ptr->flags1 & RF1_UNIQUE) != 0;
+    bool has_resistance = em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE);
     has_resistance |= em_ptr->r_ptr->level > randint1(stasis_damage) + 10;
     if (to_evil)
-        has_resistance |= (em_ptr->r_ptr->flags3 & RF3_EVIL) == 0;
+        has_resistance |= em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL);
 
     if (has_resistance) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
@@ -281,7 +278,7 @@ process_result effect_monster_stun(effect_monster_type *em_ptr)
         em_ptr->obvious = true;
 
     em_ptr->do_stun = damroll((em_ptr->caster_lev / 20) + 3, (em_ptr->dam)) + 1;
-    if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         em_ptr->do_stun = 0;
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->obvious = false;

diff --git a/src/effect/effect-monster-psi.cpp b/src/effect/effect-monster-psi.cpp
index 5d35415..2b940f5 100644 (file)
--- a/src/effect/effect-monster-psi.cpp
+++ b/src/effect/effect-monster-psi.cpp
@@ -4,6 +4,7 @@
 #include "effect/effect-monster-util.h"
 #include "floor/line-of-sight.h"
 #include "mind/mind-mirror-master.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags1.h"
 #include "monster-race/race-flags2.h"
@@ -53,7 +54,7 @@ static bool resisted_psi_because_empty_mind(PlayerType *player_ptr, effect_monst
  */
 static bool resisted_psi_because_weird_mind_or_powerful(effect_monster_type *em_ptr)
 {
-    bool has_resistance = em_ptr->r_ptr->behavior_flags.has(MonsterBehaviorType::STUPID) || any_bits(em_ptr->r_ptr->flags2, RF2_WEIRD_MIND) || any_bits(em_ptr->r_ptr->flags3, RF3_ANIMAL) || (em_ptr->r_ptr->level > randint1(3 * em_ptr->dam));
+    bool has_resistance = em_ptr->r_ptr->behavior_flags.has(MonsterBehaviorType::STUPID) || any_bits(em_ptr->r_ptr->flags2, RF2_WEIRD_MIND) || em_ptr->r_ptr->kind_flags.has(MonsterKindType::ANIMAL) || (em_ptr->r_ptr->level > randint1(3 * em_ptr->dam));
     if (!has_resistance)
         return false;
 
@@ -74,7 +75,7 @@ static bool resisted_psi_because_weird_mind_or_powerful(effect_monster_type *em_
  */
 static bool reflects_psi_with_currupted_mind(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    bool is_corrupted = any_bits(em_ptr->r_ptr->flags3, RF3_UNDEAD | RF3_DEMON) && (em_ptr->r_ptr->level > player_ptr->lev / 2) && one_in_(2);
+    bool is_corrupted = em_ptr->r_ptr->kind_flags.has_any_of(has_corrupted_mind) && (em_ptr->r_ptr->level > player_ptr->lev / 2) && one_in_(2);
     if (!is_corrupted)
         return false;
 
@@ -311,7 +312,7 @@ process_result effect_monster_telekinesis(PlayerType *player_ptr, effect_monster
     }
 
     em_ptr->do_stun = damroll((em_ptr->caster_lev / 20) + 3, em_ptr->dam) + 1;
-    if (any_bits(em_ptr->r_ptr->flags1, RF1_UNIQUE) || (em_ptr->r_ptr->level > 5 + randint1(em_ptr->dam))) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->level > 5 + randint1(em_ptr->dam))) {
         em_ptr->do_stun = 0;
         em_ptr->obvious = false;
     }

diff --git a/src/effect/effect-monster-resist-hurt.cpp b/src/effect/effect-monster-resist-hurt.cpp
index bc763f1..4989661 100644 (file)
--- a/src/effect/effect-monster-resist-hurt.cpp
+++ b/src/effect/effect-monster-resist-hurt.cpp
@@ -175,14 +175,14 @@ process_result effect_monster_hell_fire(PlayerType *player_ptr, effect_monster_t
         em_ptr->obvious = true;
     }
 
-    if ((em_ptr->r_ptr->flags3 & RF3_GOOD) == 0) {
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::GOOD)) {
         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_GOOD;
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::GOOD);
     }
 
     return PROCESS_CONTINUE;
@@ -194,20 +194,20 @@ process_result effect_monster_holy_fire(PlayerType *player_ptr, effect_monster_t
         em_ptr->obvious = true;
     }
 
-    if (any_bits(em_ptr->r_ptr->flags3, RF3_GOOD)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::GOOD)) {
         em_ptr->note = _("には完全な耐性がある！", " is immune.");
         em_ptr->dam = 0;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            set_bits(em_ptr->r_ptr->r_flags3, RF3_GOOD);
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::GOOD);
         }
         return PROCESS_CONTINUE;
     }
 
-    if (any_bits(em_ptr->r_ptr->flags3, RF3_EVIL)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
         em_ptr->dam *= 2;
         em_ptr->note = _("はひどい痛手をうけた。", " is hit hard.");
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            set_bits(em_ptr->r_ptr->r_flags3, RF3_EVIL);
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
         }
         return PROCESS_CONTINUE;
     }
@@ -245,11 +245,11 @@ static bool effect_monster_nether_resist(PlayerType *player_ptr, effect_monster_
         return false;
     }
 
-    if (em_ptr->r_ptr->flags3 & RF3_UNDEAD) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNDEAD)) {
         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_flags3 |= (RF3_UNDEAD);
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
         }
     } else {
         em_ptr->note = _("には耐性がある。", " resists.");
@@ -270,14 +270,14 @@ process_result effect_monster_nether(PlayerType *player_ptr, effect_monster_type
         em_ptr->obvious = true;
     }
 
-    if (effect_monster_nether_resist(player_ptr, em_ptr) || ((em_ptr->r_ptr->flags3 & RF3_EVIL) == 0)) {
+    if (effect_monster_nether_resist(player_ptr, em_ptr) || (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL))) {
         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_flags3 |= (RF3_EVIL);
+        em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
     }
 
     return PROCESS_CONTINUE;
@@ -322,12 +322,12 @@ process_result effect_monster_chaos(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_CHAO);
         }
-    } else if ((em_ptr->r_ptr->flags3 & RF3_DEMON) && one_in_(3)) {
+    } else if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::DEMON) && one_in_(3)) {
         em_ptr->note = _("はいくらか耐性を示した。", " resists somewhat.");
         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_flags3 |= (RF3_DEMON);
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::DEMON);
         }
     } else {
         em_ptr->do_polymorph = true;
@@ -497,7 +497,7 @@ process_result effect_monster_inertial(PlayerType *player_ptr, effect_monster_ty
         return PROCESS_CONTINUE;
     }
 
-    if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         em_ptr->obvious = false;
         return PROCESS_CONTINUE;
     }
@@ -540,7 +540,7 @@ static bool effect_monster_gravity_resist_teleport(PlayerType *player_ptr, effec
         return false;
     }
 
-    if (em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) {
+    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;
         }
@@ -563,7 +563,7 @@ static bool effect_monster_gravity_resist_teleport(PlayerType *player_ptr, effec
 
 static void effect_monster_gravity_slow(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         em_ptr->obvious = false;
         return;
     }
@@ -576,7 +576,7 @@ static void effect_monster_gravity_slow(PlayerType *player_ptr, effect_monster_t
 static void effect_monster_gravity_stun(effect_monster_type *em_ptr)
 {
     em_ptr->do_stun = damroll((em_ptr->caster_lev / 20) + 3, (em_ptr->dam)) + 1;
-    if ((em_ptr->r_ptr->flags1 & (RF1_UNIQUE)) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->level > randint1((em_ptr->dam - 10) < 1 ? 1 : (em_ptr->dam - 10)) + 10)) {
         em_ptr->do_stun = 0;
         em_ptr->note = _("には効果がなかった。", " is unaffected!");
         em_ptr->obvious = false;
@@ -669,12 +669,12 @@ process_result effect_monster_void(PlayerType *player_ptr, effect_monster_type *
         em_ptr->obvious = true;
     }
 
-    if (any_bits(em_ptr->r_ptr->flags2, RF2_QUANTUM)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::QUANTUM)) {
         em_ptr->note = _("の存在確率が減少した。", "'s wave function is reduced.");
         em_ptr->note_dies = _("は観測されなくなった。", "'s wave function collapses.");
         em_ptr->dam *= 2;
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            set_bits(em_ptr->r_ptr->r_flags2, RF2_QUANTUM);
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::QUANTUM);
         }
     } else if (any_bits(em_ptr->r_ptr->flags2, RF2_PASS_WALL)) {
         em_ptr->note = _("の存在が薄れていく。", "is fading out.");

diff --git a/src/effect/effect-monster-spirit.cpp b/src/effect/effect-monster-spirit.cpp
index b581dff..936090f 100644 (file)
--- a/src/effect/effect-monster-spirit.cpp
+++ b/src/effect/effect-monster-spirit.cpp
@@ -69,8 +69,7 @@ process_result effect_monster_mind_blast(PlayerType *player_ptr, effect_monster_
     if (!em_ptr->who)
         msg_format(_("%sをじっと睨んだ。", "You gaze intently at %s."), em_ptr->m_name);
 
-    if ((em_ptr->r_ptr->flags1 & RF1_UNIQUE) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF)
-        || (em_ptr->r_ptr->level > randint1((em_ptr->caster_lev - 10) < 1 ? 1 : (em_ptr->caster_lev - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF) || (em_ptr->r_ptr->level > randint1((em_ptr->caster_lev - 10) < 1 ? 1 : (em_ptr->caster_lev - 10)) + 10)) {
         if (em_ptr->r_ptr->flags3 & (RF3_NO_CONF)) {
             if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
                 em_ptr->r_ptr->r_flags3 |= (RF3_NO_CONF);
@@ -108,8 +107,7 @@ process_result effect_monster_brain_smash(PlayerType *player_ptr, effect_monster
     if (!em_ptr->who)
         msg_format(_("%sをじっと睨んだ。", "You gaze intently at %s."), em_ptr->m_name);
 
-    if ((em_ptr->r_ptr->flags1 & RF1_UNIQUE) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF)
-        || (em_ptr->r_ptr->level > randint1((em_ptr->caster_lev - 10) < 1 ? 1 : (em_ptr->caster_lev - 10)) + 10)) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (em_ptr->r_ptr->flags3 & RF3_NO_CONF) || (em_ptr->r_ptr->level > randint1((em_ptr->caster_lev - 10) < 1 ? 1 : (em_ptr->caster_lev - 10)) + 10)) {
         if (em_ptr->r_ptr->flags3 & (RF3_NO_CONF)) {
             if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
                 em_ptr->r_ptr->r_flags3 |= (RF3_NO_CONF);

diff --git a/src/effect/effect-monster-switcher.cpp b/src/effect/effect-monster-switcher.cpp
index c7ee343..ba7dba2 100644 (file)
--- a/src/effect/effect-monster-switcher.cpp
+++ b/src/effect/effect-monster-switcher.cpp
@@ -48,12 +48,12 @@ process_result effect_monster_hypodynamia(PlayerType *player_ptr, effect_monster
     }
 
     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-        if (em_ptr->r_ptr->flags3 & RF3_DEMON)
-            em_ptr->r_ptr->r_flags3 |= (RF3_DEMON);
-        if (em_ptr->r_ptr->flags3 & RF3_UNDEAD)
-            em_ptr->r_ptr->r_flags3 |= (RF3_UNDEAD);
-        if (em_ptr->r_ptr->flags3 & RF3_NONLIVING)
-            em_ptr->r_ptr->r_flags3 |= (RF3_NONLIVING);
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::DEMON))
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::DEMON);
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
+        if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::NONLIVING))
+            em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::NONLIVING);
     }
 
     em_ptr->note = _("には効果がなかった。", " is unaffected.");
@@ -72,12 +72,12 @@ process_result effect_monster_death_ray(PlayerType *player_ptr, effect_monster_t
 
     if (!monster_living(em_ptr->m_ptr->r_idx)) {
         if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr)) {
-            if (em_ptr->r_ptr->flags3 & RF3_DEMON)
-                em_ptr->r_ptr->r_flags3 |= (RF3_DEMON);
-            if (em_ptr->r_ptr->flags3 & RF3_UNDEAD)
-                em_ptr->r_ptr->r_flags3 |= (RF3_UNDEAD);
-            if (em_ptr->r_ptr->flags3 & RF3_NONLIVING)
-                em_ptr->r_ptr->r_flags3 |= (RF3_NONLIVING);
+            if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::DEMON))
+                em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::DEMON);
+            if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
+                em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
+            if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::NONLIVING))
+                em_ptr->r_ptr->r_kind_flags.set(MonsterKindType::NONLIVING);
         }
 
         em_ptr->note = _("には完全な耐性がある！", " is immune.");
@@ -86,8 +86,7 @@ process_result effect_monster_death_ray(PlayerType *player_ptr, effect_monster_t
         return PROCESS_CONTINUE;
     }
 
-    if (((em_ptr->r_ptr->flags1 & RF1_UNIQUE) && (randint1(888) != 666))
-        || (((em_ptr->r_ptr->level + randint1(20)) > randint1((em_ptr->caster_lev / 2) + randint1(10))) && randint1(100) != 66)) {
+    if ((em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) && (randint1(888) != 666)) || (((em_ptr->r_ptr->level + randint1(20)) > randint1((em_ptr->caster_lev / 2) + randint1(10))) && randint1(100) != 66)) {
         em_ptr->note = _("には耐性がある！", " resists!");
         em_ptr->obvious = false;
         em_ptr->dam = 0;
@@ -119,7 +118,7 @@ process_result effect_monster_hand_doom(effect_monster_type *em_ptr)
     if (em_ptr->seen)
         em_ptr->obvious = true;
 
-    if (em_ptr->r_ptr->flags1 & RF1_UNIQUE) {
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         em_ptr->note = _("には効果がなかった。", " is unaffected.");
         em_ptr->dam = 0;
         return PROCESS_CONTINUE;
@@ -180,7 +179,7 @@ process_result effect_monster_engetsu(PlayerType *player_ptr, effect_monster_typ
 
         switch (randint0(4)) {
         case 0:
-            if (!any_bits(em_ptr->r_ptr->flags1, RF1_UNIQUE)) {
+            if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
                 if (set_monster_slow(player_ptr, em_ptr->g_ptr->m_idx, monster_slow_remaining(em_ptr->m_ptr) + 50)) {
                     em_ptr->note = _("の動きが遅くなった。", " starts moving slower.");
                 }
@@ -188,7 +187,7 @@ process_result effect_monster_engetsu(PlayerType *player_ptr, effect_monster_typ
             }
             break;
         case 1:
-            if (any_bits(em_ptr->r_ptr->flags1, RF1_UNIQUE)) {
+            if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
                 em_ptr->do_stun = 0;
             } else {
                 em_ptr->do_stun = damroll((player_ptr->lev / 10) + 3, (em_ptr->dam)) + 1;
@@ -196,7 +195,7 @@ process_result effect_monster_engetsu(PlayerType *player_ptr, effect_monster_typ
             }
             break;
         case 2:
-            if (any_bits(em_ptr->r_ptr->flags1, RF1_UNIQUE) || any_bits(em_ptr->r_ptr->flags3, RF3_NO_CONF)) {
+            if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags3, RF3_NO_CONF)) {
                 if (any_bits(em_ptr->r_ptr->flags3, RF3_NO_CONF)) {
                     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
                         set_bits(em_ptr->r_ptr->r_flags3, RF3_NO_CONF);
@@ -210,7 +209,7 @@ process_result effect_monster_engetsu(PlayerType *player_ptr, effect_monster_typ
             }
             break;
         default:
-            if (any_bits(em_ptr->r_ptr->flags1, RF1_UNIQUE) || any_bits(em_ptr->r_ptr->flags3, RF3_NO_SLEEP)) {
+            if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags3, RF3_NO_SLEEP)) {
                 if (any_bits(em_ptr->r_ptr->flags3, RF3_NO_SLEEP)) {
                     if (is_original_ap_and_seen(player_ptr, em_ptr->m_ptr))
                         set_bits(em_ptr->r_ptr->r_flags3, RF3_NO_SLEEP);

diff --git a/src/effect/effect-monster.cpp b/src/effect/effect-monster.cpp
index c8ba845..e7e6504 100644 (file)
--- a/src/effect/effect-monster.cpp
+++ b/src/effect/effect-monster.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief 魔法によるモンスターへの効果まとめ
  * @date 2020/04/29
  * @author Hourier
@@ -316,9 +316,9 @@ static void effect_makes_change_virtues(PlayerType *player_ptr, effect_monster_t
     if ((em_ptr->who > 0) || !em_ptr->slept)
         return;
 
-    if (!(em_ptr->r_ptr->flags3 & RF3_EVIL) || one_in_(5))
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL) || one_in_(5))
         chg_virtue(player_ptr, V_COMPASSION, -1);
-    if (!(em_ptr->r_ptr->flags3 & RF3_EVIL) || one_in_(5))
+    if (em_ptr->r_ptr->kind_flags.has_not(MonsterKindType::EVIL) || one_in_(5))
         chg_virtue(player_ptr, V_HONOUR, -1);
 }
 
@@ -329,10 +329,10 @@ static void effect_makes_change_virtues(PlayerType *player_ptr, effect_monster_t
  */
 static void affected_monster_prevents_bad_status(PlayerType *player_ptr, effect_monster_type *em_ptr)
 {
-    if ((em_ptr->r_ptr->flags1 & RF1_UNIQUE) || (em_ptr->r_ptr->flags1 & RF1_QUESTOR) || (player_ptr->riding && (em_ptr->g_ptr->m_idx == player_ptr->riding)))
+    if (em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags1, RF1_QUESTOR) || (player_ptr->riding && (em_ptr->g_ptr->m_idx == player_ptr->riding)))
         em_ptr->do_polymorph = false;
 
-    if (((em_ptr->r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) || (em_ptr->r_ptr->flags7 & RF7_NAZGUL)) && !player_ptr->phase_out && (em_ptr->who > 0) && (em_ptr->dam > em_ptr->m_ptr->hp))
+    if ((em_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(em_ptr->r_ptr->flags1, RF1_QUESTOR) || (em_ptr->r_ptr->flags7 & RF7_NAZGUL)) && !player_ptr->phase_out && (em_ptr->who > 0) && (em_ptr->dam > em_ptr->m_ptr->hp))
         em_ptr->dam = em_ptr->m_ptr->hp;
 }
 

diff --git a/src/flavor/named-item-describer.cpp b/src/flavor/named-item-describer.cpp
index 4a77291..099d4a5 100644 (file)
--- a/src/flavor/named-item-describer.cpp
+++ b/src/flavor/named-item-describer.cpp
@@ -1,4 +1,4 @@
-#include "flavor/named-item-describer.h"
+#include "flavor/named-item-describer.h"
 #include "flavor/flavor-util.h"
 #include "flavor/object-flavor-types.h"
 #include "flavor/tval-description-switcher.h"
@@ -258,7 +258,7 @@ static void describe_artifact_prefix_en(flavor_type *flavor_ptr)
     if (describe_prefix_en(flavor_ptr))
         return;
 
-    if ((flavor_ptr->known && flavor_ptr->o_ptr->is_artifact()) || ((flavor_ptr->o_ptr->tval == ItemKindType::CORPSE) && (r_info[flavor_ptr->o_ptr->pval].flags1 & RF1_UNIQUE))) {
+    if ((flavor_ptr->known && flavor_ptr->o_ptr->is_artifact()) || ((flavor_ptr->o_ptr->tval == ItemKindType::CORPSE) && r_info[flavor_ptr->o_ptr->pval].kind_flags.has(MonsterKindType::UNIQUE))) {
         flavor_ptr->t = object_desc_str(flavor_ptr->t, "The ");
         return;
     }

diff --git a/src/flavor/tval-description-switcher.cpp b/src/flavor/tval-description-switcher.cpp
index a5b0939..8d40639 100644 (file)
--- a/src/flavor/tval-description-switcher.cpp
+++ b/src/flavor/tval-description-switcher.cpp
@@ -34,7 +34,7 @@ static void describe_monster_ball(flavor_type *flavor_ptr)
     flavor_ptr->modstr = flavor_ptr->tmp_val2;
 #else
     flavor_ptr->t = format("%s", r_ptr->name.c_str());
-    if (!(r_ptr->flags1 & RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         sprintf(flavor_ptr->tmp_val2, " (%s%s)", (is_a_vowel(*flavor_ptr->t) ? "an " : "a "), flavor_ptr->t);
         flavor_ptr->modstr = flavor_ptr->tmp_val2;
     } else {
@@ -51,7 +51,7 @@ static void describe_statue(flavor_type *flavor_ptr)
     flavor_ptr->modstr = r_ptr->name.c_str();
 #else
     flavor_ptr->t = format("%s", r_ptr->name.c_str());
-    if (!(r_ptr->flags1 & RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         sprintf(flavor_ptr->tmp_val2, "%s%s", (is_a_vowel(*flavor_ptr->t) ? "an " : "a "), flavor_ptr->t);
         flavor_ptr->modstr = flavor_ptr->tmp_val2;
     } else
@@ -66,7 +66,7 @@ static void describe_corpse(flavor_type *flavor_ptr)
 #ifdef JP
     flavor_ptr->basenm = "#%";
 #else
-    if (r_ptr->flags1 & RF1_UNIQUE)
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         flavor_ptr->basenm = "& % of #";
     else
         flavor_ptr->basenm = "& # %";

diff --git a/src/floor/fixed-map-generator.cpp b/src/floor/fixed-map-generator.cpp
index bb6e0b3..ac57702 100644 (file)
--- a/src/floor/fixed-map-generator.cpp
+++ b/src/floor/fixed-map-generator.cpp
@@ -126,7 +126,7 @@ static void parse_qtw_D(PlayerType *player_ptr, qtwg_type *qtwg_ptr, char *s)
             old_cur_num = r_info[monster_index].cur_num;
             old_max_num = r_info[monster_index].max_num;
 
-            if (r_info[monster_index].flags1 & RF1_UNIQUE) {
+            if (r_info[monster_index].kind_flags.has(MonsterKindType::UNIQUE)) {
                 r_info[monster_index].cur_num = 0;
                 r_info[monster_index].max_num = 1;
             } else if (r_info[monster_index].flags7 & RF7_NAZGUL) {
@@ -218,7 +218,7 @@ static bool parse_qtw_QQ(quest_type *q_ptr, char **zz, int num)
         q_ptr->flags = atoi(zz[10]);
 
     r_ptr = &r_info[q_ptr->r_idx];
-    if (r_ptr->flags1 & RF1_UNIQUE)
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         r_ptr->flags1 |= RF1_QUESTOR;
 
     a_ptr = &a_info[q_ptr->k_idx];

diff --git a/src/floor/floor-changer.cpp b/src/floor/floor-changer.cpp
index e6a6e47..5d47e24 100644 (file)
--- a/src/floor/floor-changer.cpp
+++ b/src/floor/floor-changer.cpp
@@ -173,7 +173,7 @@ static void update_unique_artifact(floor_type *floor_ptr, int16_t cur_floor_id)
             continue;
 
         r_ptr = real_r_ptr(m_ptr);
-        if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
             r_ptr->floor_id = cur_floor_id;
     }
 
@@ -249,7 +249,7 @@ static void reset_unique_by_floor_change(PlayerType *player_ptr)
         }
 
         r_ptr = real_r_ptr(m_ptr);
-        if (!(r_ptr->flags1 & RF1_UNIQUE) && !(r_ptr->flags7 & RF7_NAZGUL))
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && !(r_ptr->flags7 & RF7_NAZGUL))
             continue;
 
         if (r_ptr->floor_id != new_floor_id)

diff --git a/src/floor/floor-events.cpp b/src/floor/floor-events.cpp
index 270bf36..b90a0f4 100644 (file)
--- a/src/floor/floor-events.cpp
+++ b/src/floor/floor-events.cpp
@@ -127,7 +127,7 @@ static byte get_dungeon_feeling(PlayerType *player_ptr)
             continue;
 
         r_ptr = &r_info[m_ptr->r_idx];
-        if (r_ptr->flags1 & RF1_UNIQUE) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             if (r_ptr->level + 10 > floor_ptr->dun_level)
                 delta += (r_ptr->level + 10 - floor_ptr->dun_level) * 2 * base;
         } else if (r_ptr->level > floor_ptr->dun_level)

diff --git a/src/floor/floor-leaver.cpp b/src/floor/floor-leaver.cpp
index ce9e411..8f94bce 100644 (file)
--- a/src/floor/floor-leaver.cpp
+++ b/src/floor/floor-leaver.cpp
@@ -257,7 +257,7 @@ static void preserve_info(PlayerType *player_ptr)
             continue;
 
         r_ptr = real_r_ptr(m_ptr);
-        if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
             continue;
 
         delete_monster_idx(player_ptr, i);

diff --git a/src/floor/object-allocator.cpp b/src/floor/object-allocator.cpp
index 656d765..86f66c6 100644 (file)
--- a/src/floor/object-allocator.cpp
+++ b/src/floor/object-allocator.cpp
@@ -87,7 +87,7 @@ bool alloc_stairs(PlayerType *player_ptr, FEAT_IDX feat, int num, int walls)
         auto q_idx = quest_number(player_ptr, floor_ptr->dun_level);
         if (floor_ptr->dun_level > 1 && inside_quest(q_idx)) {
             auto *r_ptr = &r_info[quest[enum2i(q_idx)].r_idx];
-            if (!(r_ptr->flags1 & RF1_UNIQUE) || 0 < r_ptr->max_num)
+            if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) || 0 < r_ptr->max_num)
                 return true;
         }
 

diff --git a/src/io-dump/character-dump.cpp b/src/io-dump/character-dump.cpp
index 0b08162..7adc2e8 100644 (file)
--- a/src/io-dump/character-dump.cpp
+++ b/src/io-dump/character-dump.cpp
@@ -296,7 +296,7 @@ static void dump_aux_monsters(PlayerType *player_ptr, FILE *fff)
         if (r_ref.idx == 0 || r_ref.name.empty())
             continue;
 
-        if (r_ref.flags1 & RF1_UNIQUE) {
+        if (r_ref.kind_flags.has(MonsterKindType::UNIQUE)) {
             bool dead = (r_ref.max_num == 0);
             if (dead) {
                 norm_total++;

diff --git a/src/knowledge/knowledge-monsters.cpp b/src/knowledge/knowledge-monsters.cpp
index 0e2195d..78f378a 100644 (file)
--- a/src/knowledge/knowledge-monsters.cpp
+++ b/src/knowledge/knowledge-monsters.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @file knowledge-monsters.cpp
  * @brief 既知のモンスターに関する情報を表示する
  * @date 2020/04/24
@@ -65,7 +65,7 @@ static IDX collect_monsters(PlayerType *player_ptr, IDX grp_cur, IDX mon_idx[],
             continue;
 
         if (grp_unique) {
-            if (none_bits(r_ref.flags1, RF1_UNIQUE))
+            if (r_ref.kind_flags.has_not(MonsterKindType::UNIQUE))
                 continue;
         } else if (grp_riding) {
             if (none_bits(r_ref.flags7, RF7_RIDING))
@@ -83,7 +83,7 @@ static IDX collect_monsters(PlayerType *player_ptr, IDX grp_cur, IDX mon_idx[],
             if (!wanted)
                 continue;
         } else if (grp_amberite) {
-            if (none_bits(r_ref.flags3, RF3_AMBERITE))
+            if (r_ref.kind_flags.has_not(MonsterKindType::AMBERITE))
                 continue;
         } else {
             if (!angband_strchr(group_char, r_ref.d_char))
@@ -158,7 +158,7 @@ void do_cmd_knowledge_kill_count(PlayerType *player_ptr)
 
     int32_t total = 0;
     for (const auto &r_ref : r_info) {
-        if (any_bits(r_ref.flags1, RF1_UNIQUE)) {
+        if (r_ref.kind_flags.has(MonsterKindType::UNIQUE)) {
             bool dead = (r_ref.max_num == 0);
 
             if (dead) {
@@ -192,7 +192,7 @@ void do_cmd_knowledge_kill_count(PlayerType *player_ptr)
     ang_sort(player_ptr, who.data(), &why, who.size(), ang_sort_comp_hook, ang_sort_swap_hook);
     for (auto r_idx : who) {
         auto *r_ptr = &r_info[r_idx];
-        if (any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             bool dead = (r_ptr->max_num == 0);
             if (dead) {
                 if (r_ptr->defeat_level && r_ptr->defeat_time)
@@ -265,7 +265,7 @@ static void display_monster_list(int col, int row, int per_page, int16_t mon_idx
         term_erase(69, row + i, 255);
         term_queue_bigchar(use_bigtile ? 69 : 70, row + i, r_ptr->x_attr, r_ptr->x_char, 0, 0);
         if (!visual_only) {
-            if (none_bits(r_ptr->flags1, RF1_UNIQUE))
+            if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
                 put_str(format("%5d", r_ptr->r_pkills), row + i, 73);
             else
                 c_put_str((r_ptr->max_num == 0 ? TERM_L_DARK : TERM_WHITE), (r_ptr->max_num == 0 ? _("死亡", " dead") : _("生存", "alive")), row + i, 74);

diff --git a/src/knowledge/knowledge-uniques.cpp b/src/knowledge/knowledge-uniques.cpp
index 3804207..2ec254e 100644 (file)
--- a/src/knowledge/knowledge-uniques.cpp
+++ b/src/knowledge/knowledge-uniques.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief 既知/存命のユニークを表示する
  * @date 2020/04/23
  * @author Hourier
@@ -52,7 +52,7 @@ static bool sweep_uniques(monster_race *r_ptr, bool is_alive)
     if (r_ptr->name.empty())
         return false;
 
-    if (!(r_ptr->flags1 & RF1_UNIQUE))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
 
         return false;
 

diff --git a/src/load/old/load-v1-5-0.cpp b/src/load/old/load-v1-5-0.cpp
index 39758ce..aca58cd 100644 (file)
--- a/src/load/old/load-v1-5-0.cpp
+++ b/src/load/old/load-v1-5-0.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief 変愚蛮怒 v1.5.0以前の旧いセーブデータを読み込む処理
  * @date 2020/07/04
  * @author Hourier
@@ -339,9 +339,9 @@ void rd_monster_old(PlayerType *player_ptr, monster_type *m_ptr)
         auto *r_ptr = &r_info[m_ptr->r_idx];
 
         m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
-        if (r_ptr->flags3 & RF3_EVIL)
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
             m_ptr->sub_align |= SUB_ALIGN_EVIL;
-        if (r_ptr->flags3 & RF3_GOOD)
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
             m_ptr->sub_align |= SUB_ALIGN_GOOD;
     } else
         m_ptr->sub_align = rd_byte();
@@ -496,7 +496,7 @@ void set_old_lore(monster_race *r_ptr, BIT_FLAGS f4, const MONRACE_IDX r_idx)
     if (r_idx == MON_STORMBRINGER)
         r_ptr->r_flagsr |= RFR_RES_CHAO;
 
-    if (r_ptr->r_flags3 & RF3_ORC)
+    if (r_ptr->r_kind_flags.has(MonsterKindType::ORC))
         r_ptr->r_flagsr |= RFR_RES_DARK;
 }
 

diff --git a/src/load/quest-loader.cpp b/src/load/quest-loader.cpp
index 1b8e2b0..e8acc72 100644 (file)
--- a/src/load/quest-loader.cpp
+++ b/src/load/quest-loader.cpp
@@ -106,7 +106,7 @@ void analyze_quests(PlayerType *player_ptr, const uint16_t max_quests_load, cons
         }
 
         if (q_ptr->status == QuestStatusType::TAKEN || q_ptr->status == QuestStatusType::UNTAKEN)
-            if (r_info[q_ptr->r_idx].flags1 & RF1_UNIQUE)
+            if (r_info[q_ptr->r_idx].kind_flags.has(MonsterKindType::UNIQUE))
                 r_info[q_ptr->r_idx].flags1 |= RF1_QUESTOR;
     }
 }

diff --git a/src/lore/lore-calculator.cpp b/src/lore/lore-calculator.cpp
index 15841f8..b04f1a2 100644 (file)
--- a/src/lore/lore-calculator.cpp
+++ b/src/lore/lore-calculator.cpp
@@ -64,7 +64,7 @@ bool know_armour(MONRACE_IDX r_idx, const bool know_everything)
         return true;
     if (kills > 304 / (4 + level))
         return true;
-    if (!(r_ptr->flags1 & RF1_UNIQUE))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
         return false;
     if (kills > 304 / (38 + (5 * level) / 4))
         return true;
@@ -97,7 +97,7 @@ bool know_damage(MONRACE_IDX r_idx, int i)
         d = ((4 + level) * MAX_UCHAR - 1) / 80;
     if ((4 + level) * a > 80 * d)
         return true;
-    if (!(r_ptr->flags1 & RF1_UNIQUE))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
         return false;
     if ((4 + level) * (2 * a) > 80 * d)
         return true;

diff --git a/src/lore/magic-types-setter.cpp b/src/lore/magic-types-setter.cpp
index a6d90cb..55773e6 100644 (file)
--- a/src/lore/magic-types-setter.cpp
+++ b/src/lore/magic-types-setter.cpp
@@ -7,6 +7,7 @@
 #include "system/monster-race-definition.h"
 #include "system/player-type-definition.h"
 #include "term/term-color-types.h"
+#include "util/bit-flags-calculator.h"
 
 void set_breath_types(PlayerType *player_ptr, lore_type *lore_ptr)
 {
@@ -361,7 +362,7 @@ void set_bolt_types(PlayerType *player_ptr, lore_type *lore_ptr)
         lore_ptr->color[lore_ptr->vn++] = TERM_L_DARK;
     }
 
-     if (lore_ptr->ability_flags.has(MonsterAbilityType::BO_ABYSS)) {
+    if (lore_ptr->ability_flags.has(MonsterAbilityType::BO_ABYSS)) {
         set_damage(player_ptr, lore_ptr, MonsterAbilityType::BO_ABYSS, _("アビス・ボルト%s", "produce abyss bolts%s"));
         lore_ptr->vp[lore_ptr->vn] = lore_ptr->tmp_msg[lore_ptr->vn];
         lore_ptr->color[lore_ptr->vn++] = TERM_L_DARK;
@@ -461,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->flags3 & (RF3_UNDEAD | 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) || any_bits(lore_ptr->r_ptr->flags3, RF3_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/lore/monster-lore.cpp b/src/lore/monster-lore.cpp
index 55add50..ba4b11d 100644 (file)
--- a/src/lore/monster-lore.cpp
+++ b/src/lore/monster-lore.cpp
@@ -38,8 +38,8 @@ static void set_msex_flags(lore_type *lore_ptr)
 
 static void set_flags1(lore_type *lore_ptr)
 {
-    if (lore_ptr->r_ptr->flags1 & RF1_UNIQUE)
-        lore_ptr->flags1 |= (RF1_UNIQUE);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
+        lore_ptr->kind_flags.set(MonsterKindType::UNIQUE);
 
     if (lore_ptr->r_ptr->flags1 & RF1_QUESTOR)
         lore_ptr->flags1 |= (RF1_QUESTOR);
@@ -65,41 +65,41 @@ static void set_race_flags(lore_type *lore_ptr)
     if (!lore_ptr->r_ptr->r_tkills && !lore_ptr->know_everything)
         return;
 
-    if (lore_ptr->r_ptr->flags3 & RF3_ORC)
-        lore_ptr->flags3 |= (RF3_ORC);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::ORC))
+        lore_ptr->kind_flags.set(MonsterKindType::ORC);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_TROLL)
-        lore_ptr->flags3 |= (RF3_TROLL);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::TROLL))
+        lore_ptr->kind_flags.set(MonsterKindType::TROLL);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_GIANT)
-        lore_ptr->flags3 |= (RF3_GIANT);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::GIANT))
+        lore_ptr->kind_flags.set(MonsterKindType::GIANT);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_DRAGON)
-        lore_ptr->flags3 |= (RF3_DRAGON);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::DRAGON))
+        lore_ptr->kind_flags.set(MonsterKindType::DRAGON);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_DEMON)
-        lore_ptr->flags3 |= (RF3_DEMON);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::DEMON))
+        lore_ptr->kind_flags.set(MonsterKindType::DEMON);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_UNDEAD)
-        lore_ptr->flags3 |= (RF3_UNDEAD);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
+        lore_ptr->kind_flags.set(MonsterKindType::UNDEAD);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_EVIL)
-        lore_ptr->flags3 |= (RF3_EVIL);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::EVIL))
+        lore_ptr->kind_flags.set(MonsterKindType::EVIL);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_GOOD)
-        lore_ptr->flags3 |= (RF3_GOOD);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::GOOD))
+        lore_ptr->kind_flags.set(MonsterKindType::GOOD);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_ANIMAL)
-        lore_ptr->flags3 |= (RF3_ANIMAL);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::ANIMAL))
+        lore_ptr->kind_flags.set(MonsterKindType::ANIMAL);
 
-    if (lore_ptr->r_ptr->flags3 & RF3_AMBERITE)
-        lore_ptr->flags3 |= (RF3_AMBERITE);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::AMBERITE))
+        lore_ptr->kind_flags.set(MonsterKindType::AMBERITE);
 
-    if (lore_ptr->r_ptr->flags2 & RF2_HUMAN)
-        lore_ptr->flags2 |= (RF2_HUMAN);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::HUMAN))
+        lore_ptr->kind_flags.set(MonsterKindType::HUMAN);
 
-    if (lore_ptr->r_ptr->flags2 & RF2_QUANTUM)
-        lore_ptr->flags2 |= (RF2_QUANTUM);
+    if (lore_ptr->r_ptr->kind_flags.has(MonsterKindType::QUANTUM))
+        lore_ptr->kind_flags.set(MonsterKindType::QUANTUM);
 
     if (lore_ptr->r_ptr->flags1 & RF1_FORCE_DEPTH)
         lore_ptr->flags1 |= (RF1_FORCE_DEPTH);

diff --git a/src/main/scene-table-monster.cpp b/src/main/scene-table-monster.cpp
index 1b421de..a01803d 100644 (file)
--- a/src/main/scene-table-monster.cpp
+++ b/src/main/scene-table-monster.cpp
@@ -31,7 +31,7 @@ inline static bool has_shadower_flag(monster_type *m_ptr)
 
 inline static bool is_unique(monster_race *ap_r_ptr)
 {
-    return any_bits(ap_r_ptr->flags1, RF1_UNIQUE);
+    return ap_r_ptr->kind_flags.has(MonsterKindType::UNIQUE);
 }
 
 inline static bool is_unknown_monster(monster_race *ap_r_ptr)
@@ -92,8 +92,8 @@ static bool is_high_rate(PlayerType *player_ptr, MONSTER_IDX m_idx1, MONSTER_IDX
     auto ap_r_ptr2 = &r_info[m_ptr2->ap_r_idx];
 
     /* Unique monsters first */
-    if (any_bits(ap_r_ptr1->flags1, RF1_UNIQUE) != any_bits(ap_r_ptr2->flags1, RF1_UNIQUE))
-        return any_bits(ap_r_ptr1->flags1, RF1_UNIQUE);
+    if (ap_r_ptr1->kind_flags.has(MonsterKindType::UNIQUE) != ap_r_ptr2->kind_flags.has(MonsterKindType::UNIQUE))
+        return ap_r_ptr1->kind_flags.has(MonsterKindType::UNIQUE);
 
     /* Shadowers first (あやしい影) */
     if (m_ptr1->mflag2.has(MonsterConstantFlagType::KAGE) != m_ptr2->mflag2.has(MonsterConstantFlagType::KAGE))

diff --git a/src/market/arena.cpp b/src/market/arena.cpp
index 0603a3f..7c26138 100644 (file)
--- a/src/market/arena.cpp
+++ b/src/market/arena.cpp
@@ -200,7 +200,7 @@ void update_gambling_monsters(PlayerType *player_ptr)
                 if (!r_idx)
                     continue;
 
-                if ((r_info[r_idx].flags1 & RF1_UNIQUE) || (r_info[r_idx].flags7 & RF7_UNIQUE2)) {
+                if (r_info[r_idx].kind_flags.has(MonsterKindType::UNIQUE) || (r_info[r_idx].flags7 & RF7_UNIQUE2)) {
                     if ((r_info[r_idx].level + 10) > mon_level)
                         continue;
                 }
@@ -277,8 +277,8 @@ bool monster_arena_comm(PlayerType *player_ptr)
         auto *r_ptr = &r_info[battle_mon[i]];
 
         sprintf(buf, _("%d) %-58s  %4ld.%02ld倍", "%d) %-58s  %4ld.%02ld"), i + 1,
-            _(format("%s%s", r_ptr->name.c_str(), (r_ptr->flags1 & RF1_UNIQUE) ? "もどき" : "      "),
-                format("%s%s", (r_ptr->flags1 & RF1_UNIQUE) ? "Fake " : "", r_ptr->name.c_str())),
+            _(format("%s%s", r_ptr->name.c_str(), r_ptr->kind_flags.has(MonsterKindType::UNIQUE) ? "もどき" : "      "),
+                format("%s%s", r_ptr->kind_flags.has(MonsterKindType::UNIQUE) ? "Fake " : "", r_ptr->name.c_str())),
             (long int)mon_odds[i] / 100, (long int)mon_odds[i] % 100);
         prt(buf, 5 + i, 1);
     }

diff --git a/src/market/bounty.cpp b/src/market/bounty.cpp
index aeb37c0..f282002 100644 (file)
--- a/src/market/bounty.cpp
+++ b/src/market/bounty.cpp
@@ -101,8 +101,7 @@ bool exchange_cash(PlayerType *player_ptr)
 
     for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++) {
         o_ptr = &player_ptr->inventory_list[i];
-        if ((o_ptr->tval == ItemKindType::CORPSE) && (o_ptr->sval == SV_CORPSE)
-            && (streq(r_info[o_ptr->pval].name.c_str(), r_info[w_ptr->today_mon].name.c_str()))) {
+        if ((o_ptr->tval == ItemKindType::CORPSE) && (o_ptr->sval == SV_CORPSE) && (streq(r_info[o_ptr->pval].name.c_str(), r_info[w_ptr->today_mon].name.c_str()))) {
             char buf[MAX_NLEN + 32];
             describe_flavor(player_ptr, o_name, o_ptr, 0);
             sprintf(buf, _("%s を換金しますか？", "Convert %s into money? "), o_name);
@@ -121,8 +120,7 @@ bool exchange_cash(PlayerType *player_ptr)
     for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++) {
         o_ptr = &player_ptr->inventory_list[i];
 
-        if ((o_ptr->tval == ItemKindType::CORPSE) && (o_ptr->sval == SV_SKELETON)
-            && (streq(r_info[o_ptr->pval].name.c_str(), r_info[w_ptr->today_mon].name.c_str()))) {
+        if ((o_ptr->tval == ItemKindType::CORPSE) && (o_ptr->sval == SV_SKELETON) && (streq(r_info[o_ptr->pval].name.c_str(), r_info[w_ptr->today_mon].name.c_str()))) {
             char buf[MAX_NLEN + 32];
             describe_flavor(player_ptr, o_name, o_ptr, 0);
             sprintf(buf, _("%s を換金しますか？", "Convert %s into money? "), o_name);
@@ -240,8 +238,7 @@ void show_bounty(void)
     for (int i = 0; i < MAX_BOUNTY; i++) {
         byte color;
         concptr done_mark;
-        monster_race *r_ptr
-            = &r_info[(w_ptr->bounty_r_idx[i] > 10000 ? w_ptr->bounty_r_idx[i] - 10000 : w_ptr->bounty_r_idx[i])];
+        monster_race *r_ptr = &r_info[(w_ptr->bounty_r_idx[i] > 10000 ? w_ptr->bounty_r_idx[i] - 10000 : w_ptr->bounty_r_idx[i])];
 
         if (w_ptr->bounty_r_idx[i] > 10000) {
             color = TERM_RED;
@@ -293,7 +290,7 @@ void determine_daily_bounty(PlayerType *player_ptr, bool conv_old)
             msg_format("日替わり候補: %s ", r_ptr->name.c_str());
         }
 
-        if (r_ptr->flags1 & RF1_UNIQUE)
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
             continue;
         if (r_ptr->flags7 & (RF7_NAZGUL | RF7_UNIQUE2))
             continue;
@@ -324,7 +321,7 @@ void determine_bounty_uniques(PlayerType *player_ptr)
             monster_race *r_ptr;
             r_ptr = &r_info[w_ptr->bounty_r_idx[i]];
 
-            if (!(r_ptr->flags1 & RF1_UNIQUE))
+            if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
                 continue;
 
             if (!(r_ptr->flags9 & (RF9_DROP_CORPSE | RF9_DROP_SKELETON)))

diff --git a/src/market/building-monster.cpp b/src/market/building-monster.cpp
index bfd6463..aa587ee 100644 (file)
--- a/src/market/building-monster.cpp
+++ b/src/market/building-monster.cpp
@@ -92,11 +92,11 @@ bool research_mon(PlayerType *player_ptr)
 
         /* XTRA HACK WHATSEARCH */
         /* Require non-unique monsters if needed */
-        if (norm && (r_ref.flags1 & (RF1_UNIQUE)))
+        if (norm && r_ref.kind_flags.has(MonsterKindType::UNIQUE))
             continue;
 
         /* Require unique monsters if needed */
-        if (uniq && !(r_ref.flags1 & (RF1_UNIQUE)))
+        if (uniq && r_ref.kind_flags.has_not(MonsterKindType::UNIQUE))
             continue;
 
         /* 名前検索 */

diff --git a/src/market/building-quest.cpp b/src/market/building-quest.cpp
index bcdadec..1c75ed4 100644 (file)
--- a/src/market/building-quest.cpp
+++ b/src/market/building-quest.cpp
@@ -130,7 +130,7 @@ void castle_quest(PlayerType *player_ptr)
 
     monster_race *r_ptr;
     r_ptr = &r_info[q_ptr->r_idx];
-    while ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->rarity != 1)) {
+    while (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->rarity != 1)) {
         q_ptr->r_idx = get_mon_num(player_ptr, 0, q_ptr->level + 4 + randint1(6), 0);
         r_ptr = &r_info[q_ptr->r_idx];
     }

diff --git a/src/melee/melee-postprocess.cpp b/src/melee/melee-postprocess.cpp
index 5ebd5b9..9f68ece 100644 (file)
--- a/src/melee/melee-postprocess.cpp
+++ b/src/melee/melee-postprocess.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief モンスター同士の打撃後処理 / Melee post-process.
  * @date 2014/01/17
  * @author
@@ -42,6 +42,7 @@
 #include "system/monster-race-definition.h"
 #include "system/monster-type-definition.h"
 #include "system/player-type-definition.h"
+#include "util/bit-flags-calculator.h"
 #include "view/display-messages.h"
 
 // Melee-post-process-type
@@ -175,7 +176,7 @@ static bool check_monster_hp(PlayerType *player_ptr, mam_pp_type *mam_pp_ptr)
     if (mam_pp_ptr->m_ptr->hp < 0)
         return false;
 
-    if (((r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) || (r_ptr->flags7 & RF7_NAZGUL)) && !player_ptr->phase_out) {
+    if ((r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || r_ptr->.flags1.has(RF1_QUESTOR) || (r_ptr->flags7 & RF7_NAZGUL)) && !player_ptr->phase_out) {
         mam_pp_ptr->m_ptr->hp = 1;
         return false;
     }

diff --git a/src/melee/melee-spell-flags-checker.cpp b/src/melee/melee-spell-flags-checker.cpp
index 7991362..832da0b 100644 (file)
--- a/src/melee/melee-spell-flags-checker.cpp
+++ b/src/melee/melee-spell-flags-checker.cpp
@@ -26,6 +26,7 @@
 #include "system/monster-type-definition.h"
 #include "system/player-type-definition.h"
 #include "target/projection-path-calculator.h"
+#include "util/bit-flags-calculator.h"
 
 #include <iterator>
 
@@ -99,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->flags3 & (RF3_UNDEAD | 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) && none_bits(ms_ptr->r_ptr->flags3, RF3_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/mind/mind-cavalry.cpp b/src/mind/mind-cavalry.cpp
index 57cd5a1..9506668 100644 (file)
--- a/src/mind/mind-cavalry.cpp
+++ b/src/mind/mind-cavalry.cpp
@@ -51,7 +51,7 @@ bool rodeo(PlayerType *player_ptr)
 
     rlev = r_ptr->level;
 
-    if (r_ptr->flags1 & RF1_UNIQUE)
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         rlev = rlev * 3 / 2;
     if (rlev > 60)
         rlev = 60 + (rlev - 60) / 2;

diff --git a/src/mind/mind-samurai.cpp b/src/mind/mind-samurai.cpp
index db42a33..c47b254 100644 (file)
--- a/src/mind/mind-samurai.cpp
+++ b/src/mind/mind-samurai.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief 剣術家のレイシャルパワー処理
  * @date 2020/05/16
  * @author Hourier
@@ -139,7 +139,7 @@ static void hissatsu_zanma_ken(samurai_slaying_type *samurai_slaying_ptr)
     if (samurai_slaying_ptr->mode != HISSATSU_ZANMA)
         return;
 
-    if (!monster_living(samurai_slaying_ptr->m_ptr->r_idx) && (samurai_slaying_ptr->r_ptr->flags3 & RF3_EVIL)) {
+    if (!monster_living(samurai_slaying_ptr->m_ptr->r_idx) && samurai_slaying_ptr->r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
         if (samurai_slaying_ptr->mult < 15)
             samurai_slaying_ptr->mult = 25;
         else if (samurai_slaying_ptr->mult < 50)
@@ -261,9 +261,9 @@ static void hissatsu_keiun_kininken(PlayerType *player_ptr, samurai_slaying_type
     if (samurai_slaying_ptr->mode != HISSATSU_UNDEAD)
         return;
 
-    if (samurai_slaying_ptr->r_ptr->flags3 & RF3_UNDEAD)
+    if (samurai_slaying_ptr->r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
         if (is_original_ap_and_seen(player_ptr, samurai_slaying_ptr->m_ptr)) {
-            samurai_slaying_ptr->r_ptr->r_flags3 |= RF3_UNDEAD;
+            samurai_slaying_ptr->r_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
 
             if (samurai_slaying_ptr->mult == 10)
                 samurai_slaying_ptr->mult = 70;

diff --git a/src/mind/mind-sniper.cpp b/src/mind/mind-sniper.cpp
index 064e2d5..ea48a9b 100644 (file)
--- a/src/mind/mind-sniper.cpp
+++ b/src/mind/mind-sniper.cpp
@@ -478,28 +478,28 @@ MULTIPLY calc_snipe_damage_with_slay(PlayerType *player_ptr, MULTIPLY mult, mons
                 r_ptr->r_flags3 |= RF3_HURT_ROCK;
             if (mult < n)
                 mult = n;
-        } else if (r_ptr->flags3 & RF3_NONLIVING) {
+        } else if (r_ptr->kind_flags.has(MonsterKindType::NONLIVING)) {
             MULTIPLY n = 15 + (sniper_concent * 2);
             if (seen)
-                r_ptr->r_flags3 |= RF3_NONLIVING;
+                r_ptr->r_kind_flags.set(MonsterKindType::NONLIVING);
             if (mult < n)
                 mult = n;
         }
         break;
     case SP_EVILNESS:
-        if (r_ptr->flags3 & RF3_GOOD) {
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD)) {
             MULTIPLY n = 15 + (sniper_concent * 4);
             if (seen)
-                r_ptr->r_flags3 |= RF3_GOOD;
+                r_ptr->r_kind_flags.set(MonsterKindType::GOOD);
             if (mult < n)
                 mult = n;
         }
         break;
     case SP_HOLYNESS:
-        if (r_ptr->flags3 & RF3_EVIL) {
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
             MULTIPLY n = 12 + (sniper_concent * 3);
             if (seen)
-                r_ptr->r_flags3 |= RF3_EVIL;
+                r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
             if (r_ptr->flags3 & (RF3_HURT_LITE)) {
                 n += (sniper_concent * 3);
                 if (seen)

diff --git a/src/mind/monk-attack.cpp b/src/mind/monk-attack.cpp
index 0488d70..224f17a 100644 (file)
--- a/src/mind/monk-attack.cpp
+++ b/src/mind/monk-attack.cpp
@@ -46,7 +46,7 @@ static int calc_stun_resistance(player_attack_type *pa_ptr)
 {
     auto *r_ptr = &r_info[pa_ptr->m_ptr->r_idx];
     int resist_stun = 0;
-    if (r_ptr->flags1 & RF1_UNIQUE)
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         resist_stun += 88;
 
     if (r_ptr->flags3 & RF3_NO_STUN)
@@ -58,7 +58,7 @@ static int calc_stun_resistance(player_attack_type *pa_ptr)
     if (r_ptr->flags3 & RF3_NO_SLEEP)
         resist_stun += 33;
 
-    if ((r_ptr->flags3 & RF3_UNDEAD) || (r_ptr->flags3 & RF3_NONLIVING))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNDEAD) || r_ptr->kind_flags.has(MonsterKindType::NONLIVING))
         resist_stun += 66;
 
     return resist_stun;
@@ -194,7 +194,7 @@ static void process_attack_vital_spot(PlayerType *player_ptr, player_attack_type
     }
 
     if ((special_effect == MA_SLOW) && ((pa_ptr->attack_damage + player_ptr->to_d[pa_ptr->hand]) < pa_ptr->m_ptr->hp)) {
-        if (!(r_ptr->flags1 & RF1_UNIQUE) && (randint1(player_ptr->lev) > r_ptr->level) && pa_ptr->m_ptr->mspeed > 60) {
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && (randint1(player_ptr->lev) > r_ptr->level) && pa_ptr->m_ptr->mspeed > 60) {
             msg_format(_("%^sは足をひきずり始めた。", "You've hobbled %s."), pa_ptr->m_name);
             pa_ptr->m_ptr->mspeed -= 10;
         }

diff --git a/src/monster-attack/monster-attack-player.cpp b/src/monster-attack/monster-attack-player.cpp
index e61f4b4..debce0a 100644 (file)
--- a/src/monster-attack/monster-attack-player.cpp
+++ b/src/monster-attack/monster-attack-player.cpp
@@ -216,7 +216,7 @@ bool MonsterAttackPlayer::check_monster_continuous_attack()
     }
 
     auto *r_ptr = &r_info[this->m_ptr->r_idx];
-    if (is_pet(this->m_ptr) && (r_ptr->flags1 & RF1_UNIQUE) && (this->method == RaceBlowMethodType::EXPLODE)) {
+    if (is_pet(this->m_ptr) && r_ptr->kind_flags.has(MonsterKindType::UNIQUE) && (this->method == RaceBlowMethodType::EXPLODE)) {
         this->method = RaceBlowMethodType::HIT;
         this->d_dice /= 10;
     }
@@ -265,12 +265,12 @@ bool MonsterAttackPlayer::process_monster_attack_hit()
 bool MonsterAttackPlayer::effect_protecion_from_evil()
 {
     auto *r_ptr = &r_info[this->m_ptr->r_idx];
-    if ((this->player_ptr->protevil <= 0) || none_bits(r_ptr->flags3, RF3_EVIL) || (this->player_ptr->lev < this->rlev) || ((randint0(100) + this->player_ptr->lev) <= 50)) {
+    if ((this->player_ptr->protevil <= 0) || r_ptr->kind_flags.has_not(MonsterKindType::EVIL) || (this->player_ptr->lev < this->rlev) || ((randint0(100) + this->player_ptr->lev) <= 50)) {
         return false;
     }
 
     if (is_original_ap_and_seen(this->player_ptr, this->m_ptr)) {
-        r_ptr->r_flags3 |= RF3_EVIL;
+        r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
     }
 
 #ifdef JP

diff --git a/src/monster-floor/monster-death.cpp b/src/monster-floor/monster-death.cpp
index c8e8e45..00bd0a2 100644 (file)
--- a/src/monster-floor/monster-death.cpp
+++ b/src/monster-floor/monster-death.cpp
@@ -1,4 +1,4 @@
-#include "monster-floor/monster-death.h"
+#include "monster-floor/monster-death.h"
 #include "artifact/fixed-art-generator.h"
 #include "cmd-building/cmd-building.h"
 #include "core/player-redraw-types.h"
@@ -110,7 +110,7 @@ static void on_defeat_arena_monster(PlayerType *player_ptr, monster_death_type *
 static void drop_corpse(PlayerType *player_ptr, monster_death_type *md_ptr)
 {
     auto *floor_ptr = player_ptr->current_floor_ptr;
-    bool is_drop_corpse = one_in_(md_ptr->r_ptr->flags1 & RF1_UNIQUE ? 1 : 4);
+    bool is_drop_corpse = one_in_(md_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) ? 1 : 4);
     is_drop_corpse &= (md_ptr->r_ptr->flags9 & (RF9_DROP_CORPSE | RF9_DROP_SKELETON)) != 0;
     is_drop_corpse &= !(floor_ptr->inside_arena || player_ptr->phase_out || md_ptr->cloned
         || ((md_ptr->m_ptr->r_idx == w_ptr->today_mon) && is_pet(md_ptr->m_ptr)));
@@ -120,7 +120,7 @@ static void drop_corpse(PlayerType *player_ptr, monster_death_type *md_ptr)
     bool corpse = false;
     if (!(md_ptr->r_ptr->flags9 & RF9_DROP_SKELETON))
         corpse = true;
-    else if ((md_ptr->r_ptr->flags9 & RF9_DROP_CORPSE) && (md_ptr->r_ptr->flags1 & RF1_UNIQUE))
+    else if ((md_ptr->r_ptr->flags9 & RF9_DROP_CORPSE) && md_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         corpse = true;
     else if (md_ptr->r_ptr->flags9 & RF9_DROP_CORPSE) {
         if ((0 - ((md_ptr->m_ptr->maxhp) / 4)) > md_ptr->m_ptr->hp) {
@@ -268,7 +268,7 @@ static int decide_drop_numbers(PlayerType *player_ptr, monster_death_type *md_pt
     if (md_ptr->r_ptr->flags1 & RF1_DROP_4D2)
         drop_numbers += damroll(4, 2);
 
-    if (md_ptr->cloned && !(md_ptr->r_ptr->flags1 & RF1_UNIQUE))
+    if (md_ptr->cloned && md_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
         drop_numbers = 0;
 
     if (is_pet(md_ptr->m_ptr) || player_ptr->phase_out || player_ptr->current_floor_ptr->inside_arena)
@@ -309,7 +309,7 @@ static void drop_items_golds(PlayerType *player_ptr, monster_death_type *md_ptr,
     auto *floor_ptr = player_ptr->current_floor_ptr;
     floor_ptr->object_level = floor_ptr->base_level;
     coin_type = 0;
-    bool visible = (md_ptr->m_ptr->ml && !player_ptr->hallucinated) || ((md_ptr->r_ptr->flags1 & RF1_UNIQUE) != 0);
+    bool visible = (md_ptr->m_ptr->ml && !player_ptr->hallucinated) || (md_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE));
     if (visible && (dump_item || dump_gold))
         lore_treasure(player_ptr, md_ptr->m_idx, dump_item, dump_gold);
 }
@@ -372,7 +372,7 @@ void monster_death(PlayerType *player_ptr, MONSTER_IDX m_idx, bool drop_item, At
         w_ptr->timewalk_m_idx = 0;
 
     // プレイヤーしかユニークを倒せないのでここで時間を記録
-    if (any_bits(md_ptr->r_ptr->flags1, RF1_UNIQUE) && md_ptr->m_ptr->mflag2.has_not(MonsterConstantFlagType::CLONED)) {
+    if (md_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE) && md_ptr->m_ptr->mflag2.has_not(MonsterConstantFlagType::CLONED)) {
         update_playtime();
         md_ptr->r_ptr->defeat_time = w_ptr->play_time;
         md_ptr->r_ptr->defeat_level = player_ptr->lev;

diff --git a/src/monster-floor/monster-generator.cpp b/src/monster-floor/monster-generator.cpp
index 9c01efb..516ccd0 100644 (file)
--- a/src/monster-floor/monster-generator.cpp
+++ b/src/monster-floor/monster-generator.cpp
@@ -232,7 +232,7 @@ static bool place_monster_can_escort(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (z_ptr->level > r_ptr->level)
         return false;
 
-    if (z_ptr->flags1 & RF1_UNIQUE)
+    if (z_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         return false;
 
     if (place_monster_idx == r_idx)
@@ -345,7 +345,7 @@ bool place_monster(PlayerType *player_ptr, POSITION y, POSITION x, BIT_FLAGS mod
     if (r_idx == 0)
         return false;
 
-    if ((one_in_(5) || (player_ptr->current_floor_ptr->dun_level == 0)) && !(r_info[r_idx].flags1 & RF1_UNIQUE) && angband_strchr("hkoptuyAHLOPTUVY", r_info[r_idx].d_char)) {
+    if ((one_in_(5) || (player_ptr->current_floor_ptr->dun_level == 0)) && r_info[r_idx].kind_flags.has_not(MonsterKindType::UNIQUE) && angband_strchr("hkoptuyAHLOPTUVY", r_info[r_idx].d_char)) {
         mode |= PM_JURAL;
     }
 
@@ -373,7 +373,7 @@ bool alloc_horde(PlayerType *player_ptr, POSITION y, POSITION x, summon_specific
             return false;
 
         r_ptr = &r_info[r_idx];
-        if (r_ptr->flags1 & RF1_UNIQUE)
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
             continue;
 
         if (r_idx == MON_HAGURE)

diff --git a/src/monster-floor/monster-runaway.cpp b/src/monster-floor/monster-runaway.cpp
index 952acf5..fcdaaaf 100644 (file)
--- a/src/monster-floor/monster-runaway.cpp
+++ b/src/monster-floor/monster-runaway.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief モンスターの逃走に関する処理
  * @date 2020/03/08
  * @author Hourier
@@ -72,7 +72,7 @@ bool runaway_monster(PlayerType *player_ptr, turn_flags *turn_flags_ptr, MONSTER
     auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
     auto *r_ptr = &r_info[m_ptr->r_idx];
     bool can_runaway = is_pet(m_ptr) || is_friendly(m_ptr);
-    can_runaway &= ((r_ptr->flags1 & RF1_UNIQUE) != 0) || ((r_ptr->flags7 & RF7_NAZGUL) != 0);
+    can_runaway &= (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) || ((r_ptr->flags7 & RF7_NAZGUL) != 0);
     can_runaway &= !player_ptr->phase_out;
     if (!can_runaway)
         return false;

diff --git a/src/monster-floor/monster-summon.cpp b/src/monster-floor/monster-summon.cpp
index a0a4805..985b071 100644 (file)
--- a/src/monster-floor/monster-summon.cpp
+++ b/src/monster-floor/monster-summon.cpp
@@ -1,4 +1,4 @@
-#include "monster-floor/monster-summon.h"
+#include "monster-floor/monster-summon.h"
 #include "dungeon/dungeon-flag-types.h"
 #include "dungeon/dungeon.h"
 #include "floor/geometry.h"
@@ -55,14 +55,13 @@ static bool summon_specific_okay(PlayerType *player_ptr, MONRACE_IDX r_idx)
             return false;
     }
 
-    if (!summon_unique_okay && ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)))
+    if (!summon_unique_okay && (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)))
         return false;
 
     if (!summon_specific_type)
         return true;
 
-    if ((summon_specific_who < 0) && ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
-        && monster_has_hostile_align(player_ptr, nullptr, 10, -10, r_ptr))
+    if ((summon_specific_who < 0) && (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL)) && monster_has_hostile_align(player_ptr, nullptr, 10, -10, r_ptr))
         return false;
 
     if ((r_ptr->flags7 & RF7_CHAMELEON) && d_info[player_ptr->dungeon_idx].flags.has(DungeonFeatureType::CHAMELEON))

diff --git a/src/monster-floor/monster-sweep-grid.cpp b/src/monster-floor/monster-sweep-grid.cpp
index 2752199..cde2169 100644 (file)
--- a/src/monster-floor/monster-sweep-grid.cpp
+++ b/src/monster-floor/monster-sweep-grid.cpp
@@ -174,7 +174,7 @@ void MonsterSweepGrid::search_room_to_run(POSITION *y, POSITION *x)
 {
     auto *floor_ptr = this->player_ptr->current_floor_ptr;
     auto *r_ptr = &r_info[floor_ptr->m_list[this->m_idx].r_idx];
-    if (none_bits(r_ptr->flags3, RF3_ANIMAL) || this->can_pass_wall || any_bits(r_ptr->flags2, RF2_KILL_WALL)) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::ANIMAL) || this->can_pass_wall || any_bits(r_ptr->flags2, RF2_KILL_WALL)) {
         return;
     }
 

diff --git a/src/monster-floor/one-monster-placer.cpp b/src/monster-floor/one-monster-placer.cpp
index 5b1cb62..d7f3c61 100644 (file)
--- a/src/monster-floor/one-monster-placer.cpp
+++ b/src/monster-floor/one-monster-placer.cpp
@@ -22,6 +22,7 @@
 #include "monster-floor/monster-move.h"
 #include "monster-floor/monster-summon.h"
 #include "monster-floor/place-monster-types.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags1.h"
 #include "monster-race/race-flags2.h"
@@ -60,7 +61,7 @@ static bool is_friendly_idx(PlayerType *player_ptr, MONSTER_IDX m_idx)
 static bool monster_hook_tanuki(PlayerType *player_ptr, MONRACE_IDX r_idx)
 {
     auto *r_ptr = &r_info[r_idx];
-    bool unselectable = any_bits(r_ptr->flags1, RF1_UNIQUE);
+    bool unselectable = r_ptr->kind_flags.has(MonsterKindType::UNIQUE);
     unselectable |= any_bits(r_ptr->flags2, RF2_MULTIPLY);
     unselectable |= r_ptr->behavior_flags.has(MonsterBehaviorType::FRIENDLY);
     unselectable |= any_bits(r_ptr->flags7, RF7_AQUATIC | RF7_CHAMELEON);
@@ -114,7 +115,7 @@ static bool check_unique_placeable(PlayerType *player_ptr, MONRACE_IDX r_idx)
         return true;
 
     auto *r_ptr = &r_info[r_idx];
-    if ((any_bits(r_ptr->flags1, RF1_UNIQUE) || any_bits(r_ptr->flags7, RF7_NAZGUL)) && (r_ptr->cur_num >= r_ptr->max_num)) {
+    if ((r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(r_ptr->flags7, RF7_NAZGUL)) && (r_ptr->cur_num >= r_ptr->max_num)) {
         return false;
     }
 
@@ -201,7 +202,7 @@ static void warn_unique_generation(PlayerType *player_ptr, MONRACE_IDX r_idx)
         return;
 
     auto *r_ptr = &r_info[r_idx];
-    if (none_bits(r_ptr->flags1, RF1_UNIQUE))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
         return;
 
     concptr color;
@@ -256,7 +257,7 @@ bool place_monster_one(PlayerType *player_ptr, MONSTER_IDX who, POSITION y, POSI
         return false;
 
     msg_format_wizard(player_ptr, CHEAT_MONSTER, _("%s(Lv%d)を生成しました。", "%s(Lv%d) was generated."), name, r_ptr->level);
-    if (any_bits(r_ptr->flags1, RF1_UNIQUE) || any_bits(r_ptr->flags7, RF7_NAZGUL) || (r_ptr->level < 10))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(r_ptr->flags7, RF7_NAZGUL) || (r_ptr->level < 10))
         reset_bits(mode, PM_KAGE);
 
     g_ptr->m_idx = m_pop(floor_ptr);
@@ -277,13 +278,13 @@ bool place_monster_one(PlayerType *player_ptr, MONSTER_IDX who, POSITION y, POSI
             m_ptr->mflag2.set(MonsterConstantFlagType::KAGE);
     }
 
-    if ((who > 0) && none_bits(r_ptr->flags3, RF3_EVIL | RF3_GOOD))
+    if ((who > 0) && r_ptr->kind_flags.has_none_of(alignment_mask))
         m_ptr->sub_align = floor_ptr->m_list[who].sub_align;
     else {
         m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
-        if (any_bits(r_ptr->flags3, RF3_EVIL))
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
             set_bits(m_ptr->sub_align, SUB_ALIGN_EVIL);
-        if (any_bits(r_ptr->flags3, RF3_GOOD))
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
             set_bits(m_ptr->sub_align, SUB_ALIGN_GOOD);
     }
 
@@ -310,7 +311,7 @@ bool place_monster_one(PlayerType *player_ptr, MONSTER_IDX who, POSITION y, POSI
         choose_new_monster(player_ptr, g_ptr->m_idx, true, 0);
         r_ptr = &r_info[m_ptr->r_idx];
         m_ptr->mflag2.set(MonsterConstantFlagType::CHAMELEON);
-        if (any_bits(r_ptr->flags1, RF1_UNIQUE) && (who <= 0))
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) && (who <= 0))
             m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
     } else if (any_bits(mode, PM_KAGE) && none_bits(mode, PM_FORCE_PET)) {
         m_ptr->ap_r_idx = MON_KAGE;
@@ -388,7 +389,7 @@ bool place_monster_one(PlayerType *player_ptr, MONSTER_IDX who, POSITION y, POSI
      * Memorize location of the unique monster in saved floors.
      * A unique monster move from old saved floor.
      */
-    if (w_ptr->character_dungeon && (any_bits(r_ptr->flags1, RF1_UNIQUE) || any_bits(r_ptr->flags7, RF7_NAZGUL)))
+    if (w_ptr->character_dungeon && (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(r_ptr->flags7, RF7_NAZGUL)))
         real_r_ptr(m_ptr)->floor_id = player_ptr->floor_id;
 
     if (any_bits(r_ptr->flags2, RF2_MULTIPLY))

diff --git a/src/monster-floor/quantum-effect.cpp b/src/monster-floor/quantum-effect.cpp
index 769f0c2..5d25a51 100644 (file)
--- a/src/monster-floor/quantum-effect.cpp
+++ b/src/monster-floor/quantum-effect.cpp
@@ -1,4 +1,4 @@
-#include "monster-floor/quantum-effect.h"
+#include "monster-floor/quantum-effect.h"
 #include "floor/line-of-sight.h"
 #include "monster-floor/monster-death.h"
 #include "monster-floor/monster-remover.h"
@@ -84,14 +84,14 @@ bool process_quantum_effect(PlayerType *player_ptr, MONSTER_IDX m_idx, bool see_
 {
     auto *m_ptr = &player_ptr->current_floor_ptr->m_list[m_idx];
     auto *r_ptr = &r_info[m_ptr->r_idx];
-    if ((r_ptr->flags2 & RF2_QUANTUM) == 0)
+    if (r_ptr->kind_flags.has_not(MonsterKindType::QUANTUM))
         return false;
     if (!randint0(2))
         return false;
     if (randint0((m_idx % 100) + 10))
         return false;
 
-    bool can_disappear = (r_ptr->flags1 & RF1_UNIQUE) == 0;
+    bool can_disappear = r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE);
     can_disappear &= (r_ptr->flags1 & RF1_QUESTOR) == 0;
     if (can_disappear) {
         vanish_nonunique(player_ptr, m_idx, see_m);

diff --git a/src/monster-race/monster-race-hook.cpp b/src/monster-race/monster-race-hook.cpp
index 4ccd592..a29755d 100644 (file)
--- a/src/monster-race/monster-race-hook.cpp
+++ b/src/monster-race/monster-race-hook.cpp
@@ -377,7 +377,7 @@ bool vault_aux_jelly(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (r_ptr->behavior_flags.has(MonsterBehaviorType::KILL_BODY) && r_ptr->behavior_flags.has_not(MonsterBehaviorType::NEVER_BLOW))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_EVIL))
+    if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
         return false;
 
     if (!angband_strchr("ijm,", r_ptr->d_char))
@@ -398,7 +398,7 @@ bool vault_aux_animal(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!vault_monster_okay(player_ptr, r_idx))
         return false;
 
-    if (none_bits(r_ptr->flags3, RF3_ANIMAL))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::ANIMAL))
         return false;
 
     return true;
@@ -416,7 +416,7 @@ bool vault_aux_undead(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!vault_monster_okay(player_ptr, r_idx))
         return false;
 
-    if (none_bits(r_ptr->flags3, RF3_UNDEAD))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD))
         return false;
 
     return true;
@@ -437,7 +437,7 @@ bool vault_aux_chapel_g(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!vault_monster_okay(player_ptr, r_idx))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_EVIL))
+    if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
         return false;
 
     if ((r_idx == MON_A_GOLD) || (r_idx == MON_A_SILVER))
@@ -518,7 +518,7 @@ bool vault_aux_symbol_e(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (r_ptr->behavior_flags.has(MonsterBehaviorType::KILL_BODY) && r_ptr->behavior_flags.has_not(MonsterBehaviorType::NEVER_BLOW))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_GOOD))
+    if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
         return false;
 
     if (r_ptr->d_char != vault_aux_char)
@@ -542,7 +542,7 @@ bool vault_aux_symbol_g(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (r_ptr->behavior_flags.has(MonsterBehaviorType::KILL_BODY) && r_ptr->behavior_flags.has_not(MonsterBehaviorType::NEVER_BLOW))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_EVIL))
+    if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
         return false;
 
     if (r_ptr->d_char != vault_aux_char)
@@ -563,10 +563,10 @@ bool vault_aux_orc(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!vault_monster_okay(player_ptr, r_idx))
         return false;
 
-    if (none_bits(r_ptr->flags3, RF3_ORC))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::ORC))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_UNDEAD))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
         return false;
 
     return true;
@@ -584,10 +584,10 @@ bool vault_aux_troll(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!vault_monster_okay(player_ptr, r_idx))
         return false;
 
-    if (none_bits(r_ptr->flags3, RF3_TROLL))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::TROLL))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_UNDEAD))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
         return false;
 
     return true;
@@ -605,13 +605,13 @@ bool vault_aux_giant(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!vault_monster_okay(player_ptr, r_idx))
         return false;
 
-    if (none_bits(r_ptr->flags3, RF3_GIANT))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::GIANT))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_GOOD))
+    if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_UNDEAD))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
         return false;
 
     return true;
@@ -629,10 +629,10 @@ bool vault_aux_dragon(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (!vault_monster_okay(player_ptr, r_idx))
         return false;
 
-    if (none_bits(r_ptr->flags3, RF3_DRAGON))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::DRAGON))
         return false;
 
-    if (any_bits(r_ptr->flags3, RF3_UNDEAD))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNDEAD))
         return false;
 
     auto flags = RF_ABILITY_BREATH_MASK;
@@ -659,7 +659,7 @@ bool vault_aux_demon(PlayerType *player_ptr, MONRACE_IDX r_idx)
     if (r_ptr->behavior_flags.has(MonsterBehaviorType::KILL_BODY) && r_ptr->behavior_flags.has_not(MonsterBehaviorType::NEVER_BLOW))
         return false;
 
-    if (none_bits(r_ptr->flags3, RF3_DEMON))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::DEMON))
         return false;
 
     return true;
@@ -730,7 +730,7 @@ bool vault_aux_dark_elf(PlayerType *player_ptr, MONRACE_IDX r_idx)
 bool monster_living(MONRACE_IDX r_idx)
 {
     auto *r_ptr = &r_info[r_idx];
-    return none_bits(r_ptr->flags3, (RF3_DEMON | RF3_UNDEAD | RF3_NONLIVING));
+    return r_ptr->kind_flags.has_none_of({ MonsterKindType::DEMON, MonsterKindType::UNDEAD, MonsterKindType::NONLIVING });
 }
 
 /*!
@@ -768,7 +768,7 @@ bool monster_hook_human(PlayerType *player_ptr, MONRACE_IDX r_idx)
     (void)player_ptr;
 
     auto *r_ptr = &r_info[r_idx];
-    if (any_bits(r_ptr->flags1, RF1_UNIQUE))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         return false;
 
     if (angband_strchr("pht", r_ptr->d_char))
@@ -805,7 +805,7 @@ bool monster_is_fishing_target(PlayerType *player_ptr, MONRACE_IDX r_idx)
     (void)player_ptr;
 
     auto *r_ptr = &r_info[r_idx];
-    if (any_bits(r_ptr->flags7, RF7_AQUATIC) && none_bits(r_ptr->flags1, RF1_UNIQUE) && angband_strchr("Jjlw", r_ptr->d_char))
+    if (any_bits(r_ptr->flags7, RF7_AQUATIC) && r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && angband_strchr("Jjlw", r_ptr->d_char))
         return true;
     else
         return false;
@@ -827,7 +827,7 @@ bool monster_can_entry_arena(PlayerType *player_ptr, MONRACE_IDX r_idx)
     auto *r_ptr = &r_info[r_idx];
     bool unselectable = r_ptr->behavior_flags.has(MonsterBehaviorType::NEVER_MOVE);
     unselectable |= any_bits(r_ptr->flags2, RF2_MULTIPLY);
-    unselectable |= any_bits(r_ptr->flags2, RF2_QUANTUM) && none_bits(r_ptr->flags1, RF1_UNIQUE);
+    unselectable |= r_ptr->kind_flags.has(MonsterKindType::QUANTUM) && r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE);
     unselectable |= any_bits(r_ptr->flags7, RF7_AQUATIC);
     unselectable |= any_bits(r_ptr->flags7, RF7_CHAMELEON);
     if (unselectable)
@@ -858,7 +858,7 @@ bool item_monster_okay(PlayerType *player_ptr, MONRACE_IDX r_idx)
     (void)player_ptr;
 
     auto *r_ptr = &r_info[r_idx];
-    if (any_bits(r_ptr->flags1, RF1_UNIQUE))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         return false;
 
     if (any_bits(r_ptr->flags7, RF7_KAGE))
@@ -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) && none_bits(r_info[r_idx].flags1, RF1_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) && none_bits(r_info[r_idx].flagsr, RFR_RES_ALL) && none_bits(r_info[r_idx].flags7, RF7_AQUATIC);
 }

diff --git a/src/monster/monster-compaction.cpp b/src/monster/monster-compaction.cpp
index 5bafc1c..b3fde8e 100644 (file)
--- a/src/monster/monster-compaction.cpp
+++ b/src/monster/monster-compaction.cpp
@@ -118,7 +118,7 @@ void compact_monsters(PlayerType *player_ptr, int size)
             if ((r_ptr->flags1 & (RF1_QUESTOR)) && (cnt < 1000))
                 chance = 100;
 
-            if (r_ptr->flags1 & (RF1_UNIQUE))
+            if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
                 chance = 100;
 
             if (randint0(100) < chance)

diff --git a/src/monster/monster-damage.cpp b/src/monster/monster-damage.cpp
index aa6563a..ed3fa77 100644 (file)
--- a/src/monster/monster-damage.cpp
+++ b/src/monster/monster-damage.cpp
@@ -1,4 +1,4 @@
-/*
+/*
  * @brief モンスターがダメージを受けた時の処理と経験値の加算処理
  * @date 2021/08/04
  * @author Hourier
@@ -153,7 +153,7 @@ bool MonsterDamageProcessor::process_dead_exp_virtue(concptr note, monster_type
     this->dying_scream(m_name);
     AvatarChanger ac(player_ptr, m_ptr);
     ac.change_virtue();
-    if (any_bits(r_ptr->flags1, RF1_UNIQUE) && record_destroy_uniq) {
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) && record_destroy_uniq) {
         char note_buf[160];
         sprintf(note_buf, "%s%s", r_ptr->name.c_str(), m_ptr->mflag2.has(MonsterConstantFlagType::CLONED) ? _("(クローン)", "(Clone)") : "");
         exe_write_diary(this->player_ptr, DIARY_UNIQUE, 0, note_buf);
@@ -203,7 +203,7 @@ void MonsterDamageProcessor::death_special_flag_monster()
         return;
     }
 
-    if (none_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         return;
     }
 
@@ -300,7 +300,7 @@ void MonsterDamageProcessor::increase_kill_numbers()
 {
     auto *m_ptr = &this->player_ptr->current_floor_ptr->m_list[this->m_idx];
     auto *r_ptr = real_r_ptr(m_ptr);
-    if (((m_ptr->ml == 0) || this->player_ptr->hallucinated) && none_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (((m_ptr->ml == 0) || this->player_ptr->hallucinated) && r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         return;
     }
 
@@ -323,7 +323,7 @@ void MonsterDamageProcessor::death_amberites(GAME_TEXT *m_name)
 {
     auto *m_ptr = &this->player_ptr->current_floor_ptr->m_list[this->m_idx];
     auto *r_ptr = real_r_ptr(m_ptr);
-    if (none_bits(r_ptr->flags3, RF3_AMBERITE) || one_in_(2)) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::AMBERITE) || one_in_(2)) {
         return;
     }
 
@@ -403,7 +403,7 @@ void MonsterDamageProcessor::show_bounty_message(GAME_TEXT *m_name)
     auto *floor_ptr = this->player_ptr->current_floor_ptr;
     auto *m_ptr = &floor_ptr->m_list[this->m_idx];
     auto *r_ptr = real_r_ptr(m_ptr);
-    if (none_bits(r_ptr->flags1, RF1_UNIQUE) || m_ptr->mflag2.has(MonsterConstantFlagType::CLONED) || vanilla_town) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) || m_ptr->mflag2.has(MonsterConstantFlagType::CLONED) || vanilla_town) {
         return;
     }
 
@@ -449,7 +449,7 @@ void MonsterDamageProcessor::get_exp_from_mon(monster_type *m_ptr, HIT_POINT exp
     s64b_mul(&div_h, &div_l, 0, r_ptr->hdice * (ironman_nightmare ? 2 : 1) * compensation);
 
     /* Special penalty in the wilderness */
-    if (!this->player_ptr->current_floor_ptr->dun_level && (none_bits(r_ptr->flags8, RF8_WILD_ONLY) || none_bits(r_ptr->flags1, RF1_UNIQUE))) {
+    if (!this->player_ptr->current_floor_ptr->dun_level && (none_bits(r_ptr->flags8, RF8_WILD_ONLY) || r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))) {
         s64b_mul(&div_h, &div_l, 0, 5);
     }
 

diff --git a/src/monster/monster-describer.cpp b/src/monster/monster-describer.cpp
index efc2e1e..86c646e 100644 (file)
--- a/src/monster/monster-describer.cpp
+++ b/src/monster/monster-describer.cpp
@@ -38,7 +38,7 @@ void monster_desc(PlayerType *player_ptr, char *desc, monster_type *m_ptr, BIT_F
 
             do {
                 hallu_race = &r_info[randint1(r_info.size() - 1)];
-            } while (hallu_race->name.empty() || (hallu_race->flags1 & RF1_UNIQUE));
+            } while (hallu_race->name.empty() || hallu_race->kind_flags.has(MonsterKindType::UNIQUE));
 
             strcpy(silly_name, (hallu_race->name.c_str()));
         }
@@ -172,7 +172,7 @@ void monster_desc(PlayerType *player_ptr, char *desc, monster_type *m_ptr, BIT_F
         (void)sprintf(desc, "%s?", name);
 #endif
     } else {
-        if ((r_ptr->flags1 & RF1_UNIQUE) && !(player_ptr->hallucinated && !(mode & MD_IGNORE_HALLU))) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) && !(player_ptr->hallucinated && !(mode & MD_IGNORE_HALLU))) {
             if (m_ptr->mflag2.has(MonsterConstantFlagType::CHAMELEON) && !(mode & MD_TRUE_NAME)) {
 #ifdef JP
                 char *t;
@@ -222,7 +222,7 @@ void monster_desc(PlayerType *player_ptr, char *desc, monster_type *m_ptr, BIT_F
     }
 
     if ((mode & MD_IGNORE_HALLU) && m_ptr->mflag2.has(MonsterConstantFlagType::CHAMELEON)) {
-        if (r_ptr->flags1 & RF1_UNIQUE) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             strcat(desc, _("(カメレオンの王)", "(Chameleon Lord)"));
         } else {
             strcat(desc, _("(カメレオン)", "(Chameleon)"));

diff --git a/src/monster/monster-info.cpp b/src/monster/monster-info.cpp
index 6bc1b1a..23f4d46 100644 (file)
--- a/src/monster/monster-info.cpp
+++ b/src/monster/monster-info.cpp
@@ -221,9 +221,9 @@ bool monster_has_hostile_align(PlayerType *player_ptr, monster_type *m_ptr, int
     }
 
     /* Racial alignment flags */
-    if (r_ptr->flags3 & RF3_EVIL)
+    if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
         sub_align2 |= SUB_ALIGN_EVIL;
-    if (r_ptr->flags3 & RF3_GOOD)
+    if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
         sub_align2 |= SUB_ALIGN_GOOD;
 
     if (check_hostile_align(sub_align1, sub_align2))
@@ -303,7 +303,7 @@ MONRACE_IDX real_r_idx(monster_type *m_ptr)
 {
     auto *r_ptr = &r_info[m_ptr->r_idx];
     if (m_ptr->mflag2.has(MonsterConstantFlagType::CHAMELEON)) {
-        if (r_ptr->flags1 & RF1_UNIQUE)
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
             return MON_CHAMELEON_K;
         else
             return MON_CHAMELEON;

diff --git a/src/monster/monster-list.cpp b/src/monster/monster-list.cpp
index fdc31a0..61fb636 100644 (file)
--- a/src/monster/monster-list.cpp
+++ b/src/monster/monster-list.cpp
@@ -22,6 +22,7 @@
 #include "game-option/cheat-options.h"
 #include "grid/grid.h"
 #include "monster-floor/monster-summon.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags1.h"
 #include "monster-race/race-flags2.h"
@@ -145,7 +146,7 @@ MONRACE_IDX get_mon_num(PlayerType *player_ptr, DEPTH min_level, DEPTH max_level
         r_idx = entry.index;
         r_ptr = &r_info[r_idx];
         if (!(option & GMN_ARENA) && !chameleon_change_m_idx) {
-            if (((r_ptr->flags1 & (RF1_UNIQUE)) || (r_ptr->flags7 & (RF7_NAZGUL))) && (r_ptr->cur_num >= r_ptr->max_num)) {
+            if ((r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & (RF7_NAZGUL))) && (r_ptr->cur_num >= r_ptr->max_num)) {
                 continue;
             }
 
@@ -202,7 +203,7 @@ static bool monster_hook_chameleon_lord(PlayerType *player_ptr, MONRACE_IDX r_id
     auto *m_ptr = &floor_ptr->m_list[chameleon_change_m_idx];
     monster_race *old_r_ptr = &r_info[m_ptr->r_idx];
 
-    if (!(r_ptr->flags1 & (RF1_UNIQUE)))
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
         return false;
     if (r_ptr->behavior_flags.has(MonsterBehaviorType::FRIENDLY) || (r_ptr->flags7 & RF7_CHAMELEON))
         return false;
@@ -240,7 +241,7 @@ static bool monster_hook_chameleon(PlayerType *player_ptr, MONRACE_IDX r_idx)
     auto *m_ptr = &floor_ptr->m_list[chameleon_change_m_idx];
     monster_race *old_r_ptr = &r_info[m_ptr->r_idx];
 
-    if (r_ptr->flags1 & (RF1_UNIQUE))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         return false;
     if (r_ptr->flags2 & RF2_MULTIPLY)
         return false;
@@ -254,11 +255,11 @@ static bool monster_hook_chameleon(PlayerType *player_ptr, MONRACE_IDX r_idx)
         return false;
 
     if (!(old_r_ptr->flags7 & RF7_CHAMELEON)) {
-        if ((old_r_ptr->flags3 & RF3_GOOD) && !(r_ptr->flags3 & RF3_GOOD))
+        if (old_r_ptr->kind_flags.has(MonsterKindType::GOOD) && r_ptr->kind_flags.has_not(MonsterKindType::GOOD))
             return false;
-        if ((old_r_ptr->flags3 & RF3_EVIL) && !(r_ptr->flags3 & RF3_EVIL))
+        if (old_r_ptr->kind_flags.has(MonsterKindType::EVIL) && r_ptr->kind_flags.has_not(MonsterKindType::EVIL))
             return false;
-        if (!(old_r_ptr->flags3 & (RF3_GOOD | RF3_EVIL)) && (r_ptr->flags3 & (RF3_GOOD | RF3_EVIL)))
+        if (old_r_ptr->kind_flags.has_none_of(alignment_mask))
             return false;
     } else if (summon_specific_who > 0) {
         if (monster_has_hostile_align(player_ptr, &floor_ptr->m_list[summon_specific_who], 0, 0, r_ptr))
@@ -283,7 +284,7 @@ void choose_new_monster(PlayerType *player_ptr, MONSTER_IDX m_idx, bool born, MO
     monster_race *r_ptr;
 
     bool old_unique = false;
-    if (r_info[m_ptr->r_idx].flags1 & RF1_UNIQUE)
+    if (r_info[m_ptr->r_idx].kind_flags.has(MonsterKindType::UNIQUE))
         old_unique = true;
     if (old_unique && (r_idx == MON_CHAMELEON))
         r_idx = MON_CHAMELEON_K;
@@ -329,11 +330,11 @@ void choose_new_monster(PlayerType *player_ptr, MONSTER_IDX m_idx, bool born, MO
         player_ptr->update |= (PU_MON_LITE);
 
     if (born) {
-        if (r_ptr->flags3 & (RF3_EVIL | RF3_GOOD)) {
+        if (r_ptr->kind_flags.has_any_of(alignment_mask)) {
             m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
-            if (r_ptr->flags3 & RF3_EVIL)
+            if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
                 m_ptr->sub_align |= SUB_ALIGN_EVIL;
-            if (r_ptr->flags3 & RF3_GOOD)
+            if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
                 m_ptr->sub_align |= SUB_ALIGN_GOOD;
         }
 
@@ -378,7 +379,7 @@ void choose_new_monster(PlayerType *player_ptr, MONSTER_IDX m_idx, bool born, MO
 SPEED get_mspeed(floor_type *floor_ptr, monster_race *r_ptr)
 {
     SPEED mspeed = r_ptr->speed;
-    if (!(r_ptr->flags1 & RF1_UNIQUE) && !floor_ptr->inside_arena) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && !floor_ptr->inside_arena) {
         /* Allow some small variation per monster */
         int i = SPEED_TO_ENERGY(r_ptr->speed) / (one_in_(4) ? 3 : 10);
         if (i)

diff --git a/src/monster/monster-processor.cpp b/src/monster/monster-processor.cpp
index b574a53..2d7d11f 100644 (file)
--- a/src/monster/monster-processor.cpp
+++ b/src/monster/monster-processor.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief モンスターの特殊技能とターン経過処理 (移動等)/ Monster spells and movement for passaging a turn
  * @date 2014/01/17
  * @author
@@ -312,9 +312,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->flags1 & RF1_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->flagsr & RFR_RES_ALL)))
         gets_angry = true;
 
     if (player_ptr->phase_out || !gets_angry)

diff --git a/src/monster/monster-status-setter.cpp b/src/monster/monster-status-setter.cpp
index 48abdf7..ccd7d47 100644 (file)
--- a/src/monster/monster-status-setter.cpp
+++ b/src/monster/monster-status-setter.cpp
@@ -1,4 +1,4 @@
-#include "monster/monster-status-setter.h"
+#include "monster/monster-status-setter.h"
 #include "avatar/avatar.h"
 #include "cmd-visual/cmd-draw.h"
 #include "core/player-redraw-types.h"
@@ -9,6 +9,7 @@
 #include "dungeon/quest-completion-checker.h"
 #include "floor/cave.h"
 #include "monster-floor/monster-move.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags3.h"
 #include "monster-race/race-flags7.h"
@@ -36,7 +37,7 @@ void set_pet(PlayerType *player_ptr, monster_type *m_ptr)
 {
     QuestCompletionChecker(player_ptr, m_ptr).complete();
     m_ptr->mflag2.set(MonsterConstantFlagType::PET);
-    if (!(r_info[m_ptr->r_idx].flags3 & (RF3_EVIL | RF3_GOOD)))
+    if (r_info[m_ptr->r_idx].kind_flags.has_none_of(alignment_mask))
         m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
 }
 

diff --git a/src/monster/monster-status.cpp b/src/monster/monster-status.cpp
index fa2d703..53f3e53 100644 (file)
--- a/src/monster/monster-status.cpp
+++ b/src/monster/monster-status.cpp
@@ -7,6 +7,7 @@
 #include "game-option/birth-options.h"
 #include "game-option/text-display-options.h"
 #include "grid/grid.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags-resistance.h"
 #include "monster-race/race-flags1.h"
@@ -468,15 +469,15 @@ void monster_gain_exp(PlayerType *player_ptr, MONSTER_IDX m_idx, MONRACE_IDX s_i
     m_ptr->mspeed = get_mspeed(floor_ptr, r_ptr);
 
     /* Sub-alignment of a monster */
-    if (!is_pet(m_ptr) && none_bits(r_ptr->flags3, RF3_EVIL | RF3_GOOD)) {
+    if (!is_pet(m_ptr) && r_ptr->kind_flags.has_none_of(alignment_mask)) {
         m_ptr->sub_align = old_sub_align;
     } else {
         m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
-        if (any_bits(r_ptr->flags3, RF3_EVIL)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
             m_ptr->sub_align |= SUB_ALIGN_EVIL;
         }
 
-        if (any_bits(r_ptr->flags3, RF3_GOOD)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD)) {
             m_ptr->sub_align |= SUB_ALIGN_GOOD;
         }
     }
@@ -488,7 +489,7 @@ void monster_gain_exp(PlayerType *player_ptr, MONSTER_IDX m_idx, MONRACE_IDX s_i
                 monster_race *hallu_race;
                 do {
                     hallu_race = &r_info[randint1(r_info.size() - 1)];
-                } while (hallu_race->name.empty() || any_bits(hallu_race->flags1, RF1_UNIQUE));
+                } while (hallu_race->name.empty() || hallu_race->kind_flags.has(MonsterKindType::UNIQUE));
                 msg_format(_("%sは%sに進化した。", "%^s evolved into %s."), m_name, hallu_race->name.c_str());
             } else {
                 msg_format(_("%sは%sに進化した。", "%^s evolved into %s."), m_name, r_ptr->name.c_str());

diff --git a/src/monster/monster-update.cpp b/src/monster/monster-update.cpp
index 13fb1f2..50c8842 100644 (file)
--- a/src/monster/monster-update.cpp
+++ b/src/monster/monster-update.cpp
@@ -262,88 +262,88 @@ static void update_telepathy_sight(PlayerType *player_ptr, um_type *um_ptr, MONS
 static void update_specific_race_telepathy(PlayerType *player_ptr, um_type *um_ptr)
 {
     auto *r_ptr = &r_info[um_ptr->m_ptr->r_idx];
-    if ((player_ptr->esp_animal) && (r_ptr->flags3 & RF3_ANIMAL)) {
+    if ((player_ptr->esp_animal) && r_ptr->kind_flags.has(MonsterKindType::ANIMAL)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_ANIMAL;
+            r_ptr->r_kind_flags.set(MonsterKindType::ANIMAL);
     }
 
-    if ((player_ptr->esp_undead) && (r_ptr->flags3 & RF3_UNDEAD)) {
+    if ((player_ptr->esp_undead) && r_ptr->kind_flags.has(MonsterKindType::UNDEAD)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_UNDEAD;
+            r_ptr->r_kind_flags.set(MonsterKindType::UNDEAD);
     }
 
-    if ((player_ptr->esp_demon) && (r_ptr->flags3 & RF3_DEMON)) {
+    if ((player_ptr->esp_demon) && r_ptr->kind_flags.has(MonsterKindType::DEMON)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_DEMON;
+            r_ptr->r_kind_flags.set(MonsterKindType::DEMON);
     }
 
-    if ((player_ptr->esp_orc) && (r_ptr->flags3 & RF3_ORC)) {
+    if ((player_ptr->esp_orc) && r_ptr->kind_flags.has(MonsterKindType::ORC)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_ORC;
+            r_ptr->r_kind_flags.set(MonsterKindType::ORC);
     }
 
-    if ((player_ptr->esp_troll) && (r_ptr->flags3 & RF3_TROLL)) {
+    if ((player_ptr->esp_troll) && r_ptr->kind_flags.has(MonsterKindType::TROLL)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_TROLL;
+            r_ptr->r_kind_flags.set(MonsterKindType::TROLL);
     }
 
-    if ((player_ptr->esp_giant) && (r_ptr->flags3 & RF3_GIANT)) {
+    if ((player_ptr->esp_giant) && r_ptr->kind_flags.has(MonsterKindType::GIANT)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_GIANT;
+            r_ptr->r_kind_flags.set(MonsterKindType::GIANT);
     }
 
-    if ((player_ptr->esp_dragon) && (r_ptr->flags3 & RF3_DRAGON)) {
+    if ((player_ptr->esp_dragon) && r_ptr->kind_flags.has(MonsterKindType::DRAGON)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_DRAGON;
+            r_ptr->r_kind_flags.set(MonsterKindType::DRAGON);
     }
 
-    if ((player_ptr->esp_human) && (r_ptr->flags2 & RF2_HUMAN)) {
+    if ((player_ptr->esp_human) && r_ptr->kind_flags.has(MonsterKindType::HUMAN)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags2 |= RF2_HUMAN;
+            r_ptr->r_kind_flags.set(MonsterKindType::HUMAN);
     }
 
-    if ((player_ptr->esp_evil) && (r_ptr->flags3 & RF3_EVIL)) {
+    if ((player_ptr->esp_evil) && r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_EVIL;
+            r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
     }
 
-    if ((player_ptr->esp_good) && (r_ptr->flags3 & RF3_GOOD)) {
+    if ((player_ptr->esp_good) && r_ptr->kind_flags.has(MonsterKindType::GOOD)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_GOOD;
+            r_ptr->r_kind_flags.set(MonsterKindType::GOOD);
     }
 
-    if ((player_ptr->esp_nonliving) && ((r_ptr->flags3 & (RF3_DEMON | RF3_UNDEAD | RF3_NONLIVING)) == RF3_NONLIVING)) {
+    if ((player_ptr->esp_nonliving) && (r_ptr->kind_flags.has(MonsterKindType::NONLIVING) && r_ptr->kind_flags.has_none_of({ MonsterKindType::DEMON, MonsterKindType::UNDEAD }))) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags3 |= RF3_NONLIVING;
+            r_ptr->r_kind_flags.set(MonsterKindType::NONLIVING);
     }
 
-    if ((player_ptr->esp_unique) && (r_ptr->flags1 & RF1_UNIQUE)) {
+    if ((player_ptr->esp_unique) && r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         um_ptr->flag = true;
         um_ptr->m_ptr->mflag.set(MonsterTemporaryFlagType::ESP);
         if (is_original_ap(um_ptr->m_ptr) && !player_ptr->hallucinated)
-            r_ptr->r_flags1 |= RF1_UNIQUE;
+            r_ptr->r_kind_flags.set(MonsterKindType::UNIQUE);
     }
 }
 

diff --git a/src/mspell/mspell-floor.cpp b/src/mspell/mspell-floor.cpp
index 40dde73..92b11f5 100644 (file)
--- a/src/mspell/mspell-floor.cpp
+++ b/src/mspell/mspell-floor.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief フロアの一定範囲に効果を及ぼす (悲鳴、テレポート等)スペルの効果
  * @date 2020/05/16
  * @author Hourier
@@ -40,6 +40,7 @@
 #include "system/monster-race-definition.h"
 #include "system/monster-type-definition.h"
 #include "system/player-type-definition.h"
+#include "util/bit-flags-calculator.h"
 #include "view/display-messages.h"
 
 /*!
@@ -196,7 +197,7 @@ MonsterSpellResult spell_RF6_TELE_TO(PlayerType *player_ptr, MONSTER_IDX m_idx,
     monster_name(player_ptr, t_idx, t_name);
 
     if (tr_ptr->flagsr & RFR_RES_TELE) {
-        if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL)) {
+        if (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL)) {
             if (is_original_ap_and_seen(player_ptr, t_ptr))
                 tr_ptr->r_flagsr |= RFR_RES_TELE;
             if (see_monster(player_ptr, t_idx)) {
@@ -272,7 +273,7 @@ MonsterSpellResult spell_RF6_TELE_AWAY(PlayerType *player_ptr, MONSTER_IDX m_idx
     monster_name(player_ptr, t_idx, t_name);
 
     if (tr_ptr->flagsr & RFR_RES_TELE) {
-        if ((tr_ptr->flags1 & RF1_UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL)) {
+        if (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (tr_ptr->flagsr & RFR_RES_ALL)) {
             if (is_original_ap_and_seen(player_ptr, t_ptr))
                 tr_ptr->r_flagsr |= RFR_RES_TELE;
             if (see_monster(player_ptr, t_idx)) {
@@ -383,7 +384,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->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) && !(r_ptr->flags7 & RF7_DARK_MASK))
+    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))
         can_use_lite_area = true;
 
     if (monster_to_monster && !is_hostile(t_ptr))

diff --git a/src/mspell/mspell-lite.cpp b/src/mspell/mspell-lite.cpp
index d03beb2..5914b80 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->flags3 & (RF3_UNDEAD | RF3_HURT_LITE)) == 0) && ((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) && none_bits(msa_ptr->r_ptr->flags3, RF3_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/mspell/mspell-status.cpp b/src/mspell/mspell-status.cpp
index 5c52e67..a12da12 100644 (file)
--- a/src/mspell/mspell-status.cpp
+++ b/src/mspell/mspell-status.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief プレイヤーのステータスを下げるか、モンスター自身のステータスを上げるスペル類の処理
  * @date 2020/05/16
  * @author Hourier
@@ -453,7 +453,7 @@ MonsterSpellResult spell_RF5_HOLD(MONSTER_IDX m_idx, PlayerType *player_ptr, MON
     if (TARGET_TYPE != MONSTER_TO_MONSTER)
         return res;
 
-    resist = ((tr_ptr->flags1 & RF1_UNIQUE) != 0 || (tr_ptr->flags3 & RF3_NO_STUN) != 0);
+    resist = (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (tr_ptr->flags3 & RF3_NO_STUN) != 0);
     saving_throw = (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
 
     mspell_cast_msg_bad_status_to_monster msg(_("%^sは%sをじっと見つめた。", "%^s stares intently at %s."),
@@ -551,7 +551,7 @@ MonsterSpellResult spell_RF5_SLOW(MONSTER_IDX m_idx, PlayerType *player_ptr, MON
         msg_default = _("%sが%sの筋肉から力を吸いとった。", "%^s drains power from %s's muscles.");
     }
 
-    resist = ((tr_ptr->flags1 & RF1_UNIQUE) != 0);
+    resist = (tr_ptr->kind_flags.has(MonsterKindType::UNIQUE));
     saving_throw = (tr_ptr->level > randint1((rlev - 10) < 1 ? 1 : (rlev - 10)) + 10);
 
     mspell_cast_msg_bad_status_to_monster msg(msg_default, _("%^sには効果がなかった。", "%^s is unaffected."),

diff --git a/src/mspell/mspell-summon.cpp b/src/mspell/mspell-summon.cpp
index c3d3f68..c7f48a8 100644 (file)
--- a/src/mspell/mspell-summon.cpp
+++ b/src/mspell/mspell-summon.cpp
@@ -1,4 +1,4 @@
-#include "mspell/mspell-summon.h"
+#include "mspell/mspell-summon.h"
 #include "core/disturbance.h"
 #include "effect/effect-characteristics.h"
 #include "effect/effect-processor.h"
@@ -111,8 +111,8 @@ static void decide_summon_kin_caster(
 #ifdef JP
         (void)m_poss;
 #endif
-        _(msg_format("%sが魔法で%sを召喚した。", m_name, ((r_ptr->flags1 & RF1_UNIQUE) ? "手下" : "仲間")),
-            msg_format("%^s magically summons %s %s.", m_name, m_poss, ((r_ptr->flags1 & RF1_UNIQUE) ? "minions" : "kin")));
+        _(msg_format("%sが魔法で%sを召喚した。", m_name, (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) ? "手下" : "仲間")),
+            msg_format("%^s magically summons %s %s.", m_name, m_poss, (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) ? "minions" : "kin")));
     }
 
     if (mon_to_mon && known && !see_either)
@@ -559,7 +559,7 @@ MonsterSpellResult spell_RF6_S_ANGEL(PlayerType *player_ptr, POSITION y, POSITIO
     auto *m_ptr = &floor_ptr->m_list[m_idx];
     auto *r_ptr = &r_info[m_ptr->r_idx];
     int num = 1;
-    if (any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         num += r_ptr->level / 40;
     }
 

diff --git a/src/mspell/summon-checker.cpp b/src/mspell/summon-checker.cpp
index 8adc5f1..03467bb 100644 (file)
--- a/src/mspell/summon-checker.cpp
+++ b/src/mspell/summon-checker.cpp
@@ -1,4 +1,4 @@
-#include "mspell/summon-checker.h"
+#include "mspell/summon-checker.h"
 #include "monster-attack/monster-attack-types.h"
 #include "monster-race/monster-race-hook.h"
 #include "monster-race/monster-race.h"
@@ -39,16 +39,16 @@ bool check_summon_specific(PlayerType *player_ptr, MONRACE_IDX summoner_idx, MON
         is_match = r_ptr->d_char == 'M';
         break;
     case SUMMON_ANGEL:
-        is_match = (r_ptr->d_char == 'A') && (((r_ptr->flags3 & RF3_EVIL) != 0) || ((r_ptr->flags3 & RF3_GOOD) != 0));
+        is_match = (r_ptr->d_char == 'A') && ((r_ptr->kind_flags.has(MonsterKindType::EVIL)) || (r_ptr->kind_flags.has(MonsterKindType::GOOD)));
         break;
     case SUMMON_DEMON:
-        is_match = (r_ptr->flags3 & RF3_DEMON) != 0;
+        is_match = r_ptr->kind_flags.has(MonsterKindType::DEMON);
         break;
     case SUMMON_UNDEAD:
-        is_match = (r_ptr->flags3 & RF3_UNDEAD) != 0;
+        is_match = r_ptr->kind_flags.has(MonsterKindType::UNDEAD);
         break;
     case SUMMON_DRAGON:
-        is_match = (r_ptr->flags3 & RF3_DRAGON) != 0;
+        is_match = r_ptr->kind_flags.has(MonsterKindType::DRAGON);
         break;
     case SUMMON_HI_UNDEAD:
         is_match = (r_ptr->d_char == 'L') || (r_ptr->d_char == 'V') || (r_ptr->d_char == 'W');
@@ -57,13 +57,13 @@ bool check_summon_specific(PlayerType *player_ptr, MONRACE_IDX summoner_idx, MON
         is_match = (r_ptr->d_char == 'D');
         break;
     case SUMMON_HI_DEMON:
-        is_match = ((r_ptr->d_char == 'U') || (r_ptr->d_char == 'H') || (r_ptr->d_char == 'B')) && ((r_ptr->flags3 & RF3_DEMON) != 0);
+        is_match = ((r_ptr->d_char == 'U') || (r_ptr->d_char == 'H') || (r_ptr->d_char == 'B')) && (r_ptr->kind_flags.has(MonsterKindType::DEMON));
         break;
     case SUMMON_AMBERITES:
-        is_match = (r_ptr->flags3 & RF3_AMBERITE) != 0;
+        is_match = r_ptr->kind_flags.has(MonsterKindType::AMBERITE);
         break;
     case SUMMON_UNIQUE:
-        is_match = (r_ptr->flags1 & RF1_UNIQUE) != 0;
+        is_match = r_ptr->kind_flags.has(MonsterKindType::UNIQUE);
         break;
     case SUMMON_MOLD:
         is_match = r_ptr->d_char == 'm';
@@ -95,12 +95,10 @@ bool check_summon_specific(PlayerType *player_ptr, MONRACE_IDX summoner_idx, MON
         is_match = r_idx == MON_DAWN;
         break;
     case SUMMON_ANIMAL:
-        is_match = (r_ptr->flags3 & RF3_ANIMAL) != 0;
+        is_match = r_ptr->kind_flags.has(MonsterKindType::ANIMAL);
         break;
     case SUMMON_ANIMAL_RANGER:
-        is_match = ((r_ptr->flags3 & (RF3_ANIMAL)) && (angband_strchr("abcflqrwBCHIJKMRS", r_ptr->d_char)) && !(r_ptr->flags3 & (RF3_DRAGON))
-            && !(r_ptr->flags3 & (RF3_EVIL)) && !(r_ptr->flags3 & (RF3_UNDEAD)) && !(r_ptr->flags3 & (RF3_DEMON)) && !(r_ptr->flags2 & (RF2_MULTIPLY))
-            && r_ptr->ability_flags.none());
+        is_match = (r_ptr->kind_flags.has(MonsterKindType::ANIMAL) && (angband_strchr("abcflqrwBCHIJKMRS", r_ptr->d_char)) && r_ptr->kind_flags.has_not(MonsterKindType::DRAGON) && r_ptr->kind_flags.has_not(MonsterKindType::EVIL) && r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD) && r_ptr->kind_flags.has_not(MonsterKindType::DEMON) && !(r_ptr->flags2 & (RF2_MULTIPLY)) && r_ptr->ability_flags.none());
         break;
     case SUMMON_SMALL_MOAI:
         is_match = r_idx == MON_SMALL_MOAI;
@@ -168,10 +166,10 @@ bool check_summon_specific(PlayerType *player_ptr, MONRACE_IDX summoner_idx, MON
         is_match = r_idx == MON_PIRANHA;
         break;
     case SUMMON_ARMAGE_GOOD:
-        is_match = (r_ptr->d_char == 'A') && ((r_ptr->flags3 & RF3_GOOD) != 0);
+        is_match = (r_ptr->d_char == 'A') && (r_ptr->kind_flags.has(MonsterKindType::GOOD));
         break;
     case SUMMON_ARMAGE_EVIL:
-        is_match = ((r_ptr->flags3 & RF3_DEMON) != 0) || ((r_ptr->d_char == 'A') && ((r_ptr->flags3 & RF3_EVIL) != 0));
+        is_match = (r_ptr->kind_flags.has(MonsterKindType::DEMON)) || ((r_ptr->d_char == 'A') && (r_ptr->kind_flags.has(MonsterKindType::EVIL)));
         break;
     case SUMMON_APOCRYPHA_FOLLOWERS:
         is_match = (r_idx == MON_FOLLOWER_WARRIOR) || (r_idx == MON_FOLLOWER_MAGE);

diff --git a/src/object-activation/activation-others.cpp b/src/object-activation/activation-others.cpp
index 36203b2..1081da6 100644 (file)
--- a/src/object-activation/activation-others.cpp
+++ b/src/object-activation/activation-others.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief 発動処理その他 (肥大化しがちなので適宜まとまりを別ファイルへ分割すること)
  * @date 2020/08/19
  * @author Hourier
@@ -169,7 +169,7 @@ bool activate_unique_detection(PlayerType *player_ptr)
             continue;
 
         r_ptr = &r_info[m_ptr->r_idx];
-        if (r_ptr->flags1 & RF1_UNIQUE) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             msg_format(_("%s． ", "%s. "), r_ptr->name.c_str());
         }
 

diff --git a/src/pet/pet-util.cpp b/src/pet/pet-util.cpp
index c01ba4b..ebaaa13 100644 (file)
--- a/src/pet/pet-util.cpp
+++ b/src/pet/pet-util.cpp
@@ -80,7 +80,7 @@ PERCENTAGE calculate_upkeep(PlayerType *player_ptr)
         }
 
         total_friends++;
-        if (none_bits(r_ptr->flags1, RF1_UNIQUE)) {
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
             total_friend_levels += r_ptr->level;
             continue;
         }

diff --git a/src/player-attack/attack-chaos-effect.cpp b/src/player-attack/attack-chaos-effect.cpp
index 2de7729..71b95e8 100644 (file)
--- a/src/player-attack/attack-chaos-effect.cpp
+++ b/src/player-attack/attack-chaos-effect.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief 特殊属性武器で攻撃した際の追加効果処理
  * @date 2020/05/23
  * @author Hourier
@@ -173,7 +173,7 @@ static bool judge_tereprt_resistance(PlayerType *player_ptr, player_attack_type
     if ((r_ptr->flagsr & RFR_RES_TELE) == 0)
         return false;
 
-    if (r_ptr->flags1 & RF1_UNIQUE) {
+    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;
 
@@ -219,7 +219,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->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) != 0) || ((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->flagsr & RFR_EFF_RES_CHAO_MASK) != 0))
         return;
 
     if (polymorph_monster(player_ptr, y, x)) {

diff --git a/src/player-attack/player-attack.cpp b/src/player-attack/player-attack.cpp
index b702250..c297362 100644 (file)
--- a/src/player-attack/player-attack.cpp
+++ b/src/player-attack/player-attack.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief プレイヤーからモンスターへの打撃処理
  * @date 2020/05/22
  * @author Hourier
@@ -392,7 +392,7 @@ static void apply_damage_negative_effect(player_attack_type *pa_ptr, bool is_zan
         pa_ptr->attack_damage = 0;
 
     auto *r_ptr = &r_info[pa_ptr->m_ptr->r_idx];
-    if ((pa_ptr->mode == HISSATSU_ZANMA) && !(!monster_living(pa_ptr->m_ptr->r_idx) && (r_ptr->flags3 & RF3_EVIL))) {
+    if ((pa_ptr->mode == HISSATSU_ZANMA) && !(!monster_living(pa_ptr->m_ptr->r_idx) && r_ptr->kind_flags.has(MonsterKindType::EVIL))) {
         pa_ptr->attack_damage = 0;
     }
 

diff --git a/src/player-info/alignment.cpp b/src/player-info/alignment.cpp
index 97ce7a5..9112344 100644 (file)
--- a/src/player-info/alignment.cpp
+++ b/src/player-info/alignment.cpp
@@ -52,11 +52,11 @@ void PlayerAlignment::update_alignment()
         if (!is_pet(m_ptr))
             continue;
 
-        if (any_bits(r_ptr->flags3, RF3_GOOD)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD)) {
             this->bias_good_alignment(r_ptr->level);
         }
 
-        if (any_bits(r_ptr->flags3, RF3_EVIL)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
             this->bias_evil_alignment(r_ptr->level);
         }
     }

diff --git a/src/player/eldritch-horror.cpp b/src/player/eldritch-horror.cpp
index 6d409bb..a0dacef 100644 (file)
--- a/src/player/eldritch-horror.cpp
+++ b/src/player/eldritch-horror.cpp
@@ -45,7 +45,7 @@ static concptr decide_horror_message(monster_race *r_ptr)
         return horror_desc_common[horror_num];
     }
 
-    if ((r_ptr->flags3 & RF3_EVIL) != 0) {
+    if (r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
         return horror_desc_evil[horror_num - MAX_SAN_HORROR_COMMON];
     }
 
@@ -93,7 +93,7 @@ void sanity_blast(PlayerType *player_ptr, monster_type *m_ptr, bool necro)
         auto *r_ptr = &r_info[m_ptr->ap_r_idx];
         power = r_ptr->level / 2;
         monster_desc(player_ptr, m_name, m_ptr, 0);
-        if (!(r_ptr->flags1 & RF1_UNIQUE)) {
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
             if (r_ptr->flags1 & RF1_FRIENDS)
                 power /= 2;
         } else
@@ -150,13 +150,13 @@ void sanity_blast(PlayerType *player_ptr, monster_type *m_ptr, bool necro)
 #ifdef JP
 #else
 
-        if (!(r_ptr->flags1 & RF1_UNIQUE))
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
             sprintf(m_name, "%s %s", (is_a_vowel(desc[0]) ? "an" : "a"), desc);
         else
 #endif
         sprintf(m_name, "%s", desc);
 
-        if (!(r_ptr->flags1 & RF1_UNIQUE)) {
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
             if (r_ptr->flags1 & RF1_FRIENDS)
                 power /= 2;
         } else

diff --git a/src/room/rooms-pit-nest.cpp b/src/room/rooms-pit-nest.cpp
index 1f6748c..9647eca 100644 (file)
--- a/src/room/rooms-pit-nest.cpp
+++ b/src/room/rooms-pit-nest.cpp
@@ -267,9 +267,9 @@ bool build_type5(PlayerType *player_ptr, dun_data_type *dd_ptr)
             return false;
 
         /* Note the alignment */
-        if (r_ptr->flags3 & RF3_EVIL)
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
             align.sub_align |= SUB_ALIGN_EVIL;
-        if (r_ptr->flags3 & RF3_GOOD)
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
             align.sub_align |= SUB_ALIGN_GOOD;
 
         nest_mon_info[i].r_idx = (int16_t)r_idx;
@@ -494,9 +494,9 @@ bool build_type6(PlayerType *player_ptr, dun_data_type *dd_ptr)
             return false;
 
         /* Note the alignment */
-        if (r_ptr->flags3 & RF3_EVIL)
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
             align.sub_align |= SUB_ALIGN_EVIL;
-        if (r_ptr->flags3 & RF3_GOOD)
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
             align.sub_align |= SUB_ALIGN_GOOD;
 
         what[i] = r_idx;
@@ -799,9 +799,9 @@ bool build_type13(PlayerType *player_ptr, dun_data_type *dd_ptr)
             return false;
 
         /* Note the alignment */
-        if (r_ptr->flags3 & RF3_EVIL)
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
             align.sub_align |= SUB_ALIGN_EVIL;
-        if (r_ptr->flags3 & RF3_GOOD)
+        if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
             align.sub_align |= SUB_ALIGN_GOOD;
 
         what[i] = r_idx;

diff --git a/src/spell-kind/spells-detection.cpp b/src/spell-kind/spells-detection.cpp
index 44c8a3c..dba40f0 100644 (file)
--- a/src/spell-kind/spells-detection.cpp
+++ b/src/spell-kind/spells-detection.cpp
@@ -1,4 +1,4 @@
-#include "spell-kind/spells-detection.h"
+#include "spell-kind/spells-detection.h"
 #include "core/window-redrawer.h"
 #include "dungeon/dungeon-flag-types.h"
 #include "dungeon/dungeon.h"
@@ -414,9 +414,9 @@ bool detect_monsters_evil(PlayerType *player_ptr, POSITION range)
         if (distance(player_ptr->y, player_ptr->x, y, x) > range)
             continue;
 
-        if (r_ptr->flags3 & RF3_EVIL) {
+        if (r_ptr->kind_flags.has(MonsterKindType::EVIL)) {
             if (is_original_ap(m_ptr)) {
-                r_ptr->r_flags3 |= (RF3_EVIL);
+                r_ptr->r_kind_flags.set(MonsterKindType::EVIL);
                 if (player_ptr->monster_race_idx == m_ptr->r_idx) {
                     player_ptr->window_flags |= (PW_MONSTER);
                 }

diff --git a/src/spell-kind/spells-genocide.cpp b/src/spell-kind/spells-genocide.cpp
index fcb4bd1..8b7e54d 100644 (file)
--- a/src/spell-kind/spells-genocide.cpp
+++ b/src/spell-kind/spells-genocide.cpp
@@ -29,6 +29,7 @@
 #include "system/monster-type-definition.h"
 #include "system/player-type-definition.h"
 #include "view/display-messages.h"
+#include "util/bit-flags-calculator.h"
 
 /*!
  * @brief モンスターへの単体抹殺処理サブルーチン / Delete a non-unique/non-quest monster
@@ -47,7 +48,7 @@ bool genocide_aux(PlayerType *player_ptr, MONSTER_IDX m_idx, int power, bool pla
         return false;
 
     bool resist = false;
-    if (r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(r_ptr->flags1, RF1_QUESTOR))
         resist = true;
     else if (r_ptr->flags7 & RF7_UNIQUE2)
         resist = true;
@@ -208,7 +209,7 @@ bool mass_genocide_undead(PlayerType *player_ptr, int power, bool player_cast)
         auto *r_ptr = &r_info[m_ptr->r_idx];
         if (!monster_is_valid(m_ptr))
             continue;
-        if (!(r_ptr->flags3 & RF3_UNDEAD))
+        if (r_ptr->kind_flags.has_not(MonsterKindType::UNDEAD))
             continue;
         if (m_ptr->cdis > MAX_SIGHT)
             continue;

diff --git a/src/spell-kind/spells-pet.cpp b/src/spell-kind/spells-pet.cpp
index 9592056..973b2f8 100644 (file)
--- a/src/spell-kind/spells-pet.cpp
+++ b/src/spell-kind/spells-pet.cpp
@@ -1,4 +1,4 @@
-#include "spell-kind/spells-pet.h"
+#include "spell-kind/spells-pet.h"
 #include "core/asking-player.h"
 #include "effect/effect-characteristics.h"
 #include "effect/effect-processor.h"
@@ -44,7 +44,7 @@ void discharge_minion(PlayerType *player_ptr)
 
         monster_race *r_ptr;
         r_ptr = &r_info[m_ptr->r_idx];
-        if (r_ptr->flags1 & RF1_UNIQUE) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             GAME_TEXT m_name[MAX_NLEN];
             monster_desc(player_ptr, m_name, m_ptr, 0x00);
             msg_format(_("%sは爆破されるのを嫌がり、勝手に自分の世界へと帰った。", "%^s resists being blasted and runs away."), m_name);

diff --git a/src/spell-kind/spells-polymorph.cpp b/src/spell-kind/spells-polymorph.cpp
index 8e909c2..37e3d1c 100644 (file)
--- a/src/spell-kind/spells-polymorph.cpp
+++ b/src/spell-kind/spells-polymorph.cpp
@@ -18,6 +18,7 @@
 #include "system/object-type-definition.h"
 #include "system/player-type-definition.h"
 #include "target/target-checker.h"
+#include "util/bit-flags-calculator.h"
 
 /*!
  * @brief 変身処理向けにモンスターの近隣レベル帯モンスターを返す /
@@ -31,7 +32,7 @@
 static MONRACE_IDX poly_r_idx(PlayerType *player_ptr, MONRACE_IDX r_idx)
 {
     auto *r_ptr = &r_info[r_idx];
-    if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags1 & RF1_QUESTOR))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || any_bits(r_ptr->flags1, RF1_QUESTOR))
         return r_idx;
 
     DEPTH lev1 = r_ptr->level - ((randint1(20) / randint1(9)) + 1);
@@ -43,7 +44,7 @@ static MONRACE_IDX poly_r_idx(PlayerType *player_ptr, MONRACE_IDX r_idx)
             break;
 
         r_ptr = &r_info[r];
-        if (r_ptr->flags1 & RF1_UNIQUE)
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
             continue;
         if ((r_ptr->level < lev1) || (r_ptr->level > lev2))
             continue;

diff --git a/src/spell-kind/spells-sight.cpp b/src/spell-kind/spells-sight.cpp
index 5a4444e..eb3f15b 100644 (file)
--- a/src/spell-kind/spells-sight.cpp
+++ b/src/spell-kind/spells-sight.cpp
@@ -1,4 +1,4 @@
-#include "spell-kind/spells-sight.h"
+#include "spell-kind/spells-sight.h"
 #include "avatar/avatar.h"
 #include "core/player-update-types.h"
 #include "core/stuff-handler.h"
@@ -13,6 +13,7 @@
 #include "io/input-key-acceptor.h"
 #include "locale/english.h"
 #include "lore/lore-store.h"
+#include "monster-race/monster-kind-mask.h"
 #include "monster-race/monster-race.h"
 #include "monster-race/race-flags3.h"
 #include "monster/monster-describer.h"
@@ -381,11 +382,11 @@ void probed_monster_info(char *buf, PlayerType *player_ptr, monster_type *m_ptr,
         speed += 5;
 
     concptr align;
-    if ((r_ptr->flags3 & (RF3_EVIL | RF3_GOOD)) == (RF3_EVIL | RF3_GOOD))
+    if (r_ptr->kind_flags.has_all_of(alignment_mask))
         align = _("善悪", "good&evil");
-    else if (r_ptr->flags3 & RF3_EVIL)
+    else if (r_ptr->kind_flags.has(MonsterKindType::EVIL))
         align = _("邪悪", "evil");
-    else if (r_ptr->flags3 & RF3_GOOD)
+    else if (r_ptr->kind_flags.has(MonsterKindType::GOOD))
         align = _("善良", "good");
     else if ((m_ptr->sub_align & (SUB_ALIGN_EVIL | SUB_ALIGN_GOOD)) == (SUB_ALIGN_EVIL | SUB_ALIGN_GOOD))
         align = _("中立(善悪)", "neutral(good&evil)");

diff --git a/src/spell/spells-diceroll.cpp b/src/spell/spells-diceroll.cpp
index 07d8a6c..dea1308 100644 (file)
--- a/src/spell/spells-diceroll.cpp
+++ b/src/spell/spells-diceroll.cpp
@@ -46,7 +46,7 @@ bool common_saving_throw_charm(PlayerType *player_ptr, HIT_POINT pow, monster_ty
         return true;
 
     pow += (adj_chr_chm[player_ptr->stat_index[A_CHR]] - 1);
-    if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
         pow = pow * 2 / 3;
     return (r_ptr->level > randint1((pow - 10) < 1 ? 1 : (pow - 10)) + 5);
 }
@@ -75,7 +75,7 @@ bool common_saving_throw_control(PlayerType *player_ptr, HIT_POINT pow, monster_
         return true;
 
     pow += adj_chr_chm[player_ptr->stat_index[A_CHR]] - 1;
-    if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE) || (r_ptr->flags7 & RF7_NAZGUL))
         pow = pow * 2 / 3;
     return (r_ptr->level > randint1((pow - 10) < 1 ? 1 : (pow - 10)) + 5);
 }

diff --git a/src/spell/spells-object.cpp b/src/spell/spells-object.cpp
index e7f9cd1..5f88d6f 100644 (file)
--- a/src/spell/spells-object.cpp
+++ b/src/spell/spells-object.cpp
@@ -1,4 +1,4 @@
-/*!
+/*!
  * @brief アイテムに影響のある魔法の処理
  * @date 2019/01/22
  * @author deskull
@@ -147,7 +147,7 @@ void amusement(PlayerType *player_ptr, POSITION y1, POSITION x1, int num, bool k
         apply_magic_to_object(player_ptr, i_ptr, 1, AM_NO_FIXED_ART);
 
         if (amuse_info[i].flag & AMS_NO_UNIQUE) {
-            if (r_info[i_ptr->pval].flags1 & RF1_UNIQUE)
+            if (r_info[i_ptr->pval].kind_flags.has(MonsterKindType::UNIQUE))
                 continue;
         }
 

diff --git a/src/store/service-checker.cpp b/src/store/service-checker.cpp
index c344b7c..1db758b 100644 (file)
--- a/src/store/service-checker.cpp
+++ b/src/store/service-checker.cpp
@@ -104,8 +104,8 @@ static bool check_store_temple(const ObjectType *o_ptr)
     case ItemKindType::FIGURINE:
     case ItemKindType::STATUE: {
         auto *r_ptr = &r_info[o_ptr->pval];
-        if (!(r_ptr->flags3 & RF3_EVIL))
-            if (((r_ptr->flags3 & RF3_GOOD) != 0) || ((r_ptr->flags3 & RF3_ANIMAL) != 0) || (angband_strchr("?!", r_ptr->d_char) != nullptr))
+        if (r_ptr->kind_flags.has_not(MonsterKindType::EVIL))
+            if ((r_ptr->kind_flags.has(MonsterKindType::GOOD)) || (r_ptr->kind_flags.has(MonsterKindType::ANIMAL)) || (angband_strchr("?!", r_ptr->d_char) != nullptr))
                 return true;
     }
         /* Fall through */

diff --git a/src/target/target-preparation.cpp b/src/target/target-preparation.cpp
index a712c99..2898ab3 100644 (file)
--- a/src/target/target-preparation.cpp
+++ b/src/target/target-preparation.cpp
@@ -189,8 +189,8 @@ void target_sensing_monsters_prepare(PlayerType *player_ptr, std::vector<MONSTER
         auto ap_r_ptr2 = &r_info[m_ptr2->ap_r_idx];
 
         /* Unique monsters first */
-        if (any_bits(ap_r_ptr1->flags1, RF1_UNIQUE) != any_bits(ap_r_ptr2->flags1, RF1_UNIQUE))
-            return any_bits(ap_r_ptr1->flags1, RF1_UNIQUE);
+        if (ap_r_ptr1->kind_flags.has(MonsterKindType::UNIQUE) != ap_r_ptr2->kind_flags.has(MonsterKindType::UNIQUE))
+            return ap_r_ptr1->kind_flags.has(MonsterKindType::UNIQUE);
 
         /* Shadowers first (あやしい影) */
         if (m_ptr1->mflag2.has(MonsterConstantFlagType::KAGE) != m_ptr2->mflag2.has(MonsterConstantFlagType::KAGE))

diff --git a/src/util/sort.cpp b/src/util/sort.cpp
index e35dd96..46a3899 100644 (file)
--- a/src/util/sort.cpp
+++ b/src/util/sort.cpp
@@ -149,9 +149,9 @@ bool ang_sort_comp_importance(PlayerType *player_ptr, vptr u, vptr v, int a, int
     /* Compare two monsters */
     if (ap_ra_ptr && ap_rb_ptr) {
         /* Unique monsters first */
-        if ((ap_ra_ptr->flags1 & RF1_UNIQUE) && !(ap_rb_ptr->flags1 & RF1_UNIQUE))
+        if (ap_ra_ptr->kind_flags.has(MonsterKindType::UNIQUE) && ap_rb_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
             return true;
-        if (!(ap_ra_ptr->flags1 & RF1_UNIQUE) && (ap_rb_ptr->flags1 & RF1_UNIQUE))
+        if (ap_ra_ptr->kind_flags.has_not(MonsterKindType::UNIQUE) && ap_rb_ptr->kind_flags.has(MonsterKindType::UNIQUE))
             return false;
 
         /* Shadowers first (あやしい影) */
@@ -358,10 +358,10 @@ bool ang_sort_comp_pet(PlayerType *player_ptr, vptr u, vptr v, int a, int b)
     if (m_ptr2->nickname && !m_ptr1->nickname)
         return false;
 
-    if ((r_ptr1->flags1 & RF1_UNIQUE) && !(r_ptr2->flags1 & RF1_UNIQUE))
+    if (r_ptr1->kind_flags.has(MonsterKindType::UNIQUE) && r_ptr2->kind_flags.has_not(MonsterKindType::UNIQUE))
         return true;
 
-    if ((r_ptr2->flags1 & RF1_UNIQUE) && !(r_ptr1->flags1 & RF1_UNIQUE))
+    if (r_ptr2->kind_flags.has(MonsterKindType::UNIQUE) && r_ptr1->kind_flags.has_not(MonsterKindType::UNIQUE))
         return false;
 
     if (r_ptr1->level > r_ptr2->level)
@@ -507,10 +507,10 @@ bool ang_sort_comp_monster_level(PlayerType *player_ptr, vptr u, vptr v, int a,
     if (r_ptr1->level > r_ptr2->level)
         return false;
 
-    if ((r_ptr2->flags1 & RF1_UNIQUE) && !(r_ptr1->flags1 & RF1_UNIQUE))
+    if (r_ptr2->kind_flags.has(MonsterKindType::UNIQUE) && r_ptr1->kind_flags.has_not(MonsterKindType::UNIQUE))
         return true;
 
-    if ((r_ptr1->flags1 & RF1_UNIQUE) && !(r_ptr2->flags1 & RF1_UNIQUE))
+    if (r_ptr1->kind_flags.has(MonsterKindType::UNIQUE) && r_ptr2->kind_flags.has_not(MonsterKindType::UNIQUE))
         return false;
 
     return w1 <= w2;
@@ -557,10 +557,10 @@ bool ang_sort_comp_pet_dismiss(PlayerType *player_ptr, vptr u, vptr v, int a, in
     if (!m_ptr2->parent_m_idx && m_ptr1->parent_m_idx)
         return false;
 
-    if ((r_ptr1->flags1 & RF1_UNIQUE) && !(r_ptr2->flags1 & RF1_UNIQUE))
+    if (r_ptr1->kind_flags.has(MonsterKindType::UNIQUE) && r_ptr2->kind_flags.has_not(MonsterKindType::UNIQUE))
         return true;
 
-    if ((r_ptr2->flags1 & RF1_UNIQUE) && !(r_ptr1->flags1 & RF1_UNIQUE))
+    if (r_ptr2->kind_flags.has(MonsterKindType::UNIQUE) && r_ptr1->kind_flags.has_not(MonsterKindType::UNIQUE))
         return false;
 
     if (r_ptr1->level > r_ptr2->level)

diff --git a/src/view/display-lore-status.cpp b/src/view/display-lore-status.cpp
index 7717bf5..4496b6e 100644 (file)
--- a/src/view/display-lore-status.cpp
+++ b/src/view/display-lore-status.cpp
@@ -301,7 +301,7 @@ void display_monster_concrete_resistances(lore_type *lore_ptr)
         lore_ptr->color[lore_ptr->vn++] = TERM_YELLOW;
     }
 
-    if ((lore_ptr->flagsr & RFR_RES_TELE) && !(lore_ptr->r_ptr->flags1 & RF1_UNIQUE)) {
+    if ((lore_ptr->flagsr & RFR_RES_TELE) && 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;
     }
@@ -341,7 +341,7 @@ void display_monster_evolution(lore_type *lore_ptr)
         hook_c_roff(TERM_YELLOW, format("%s", r_info[lore_ptr->r_ptr->next_r_idx].name.c_str()));
 
         hooked_roff(_(format("に進化する。"), format(" when %s gets enough experience.  ", Who::who(lore_ptr->msex))));
-    } else if (!(lore_ptr->r_ptr->flags1 & RF1_UNIQUE)) {
+    } else if (lore_ptr->r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         hooked_roff(format(_("%sは進化しない。", "%s won't evolve.  "), Who::who(lore_ptr->msex)));
     }
 }
@@ -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->flags1 & RF1_UNIQUE)) {
+    if ((lore_ptr->flagsr & RFR_RES_TELE) && lore_ptr->r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         lore_ptr->vp[lore_ptr->vn] = _("テレポートされない", "teleported");
         lore_ptr->color[lore_ptr->vn++] = TERM_ORANGE;
     }

diff --git a/src/view/display-lore.cpp b/src/view/display-lore.cpp
index 587d689..92f7acd 100644 (file)
--- a/src/view/display-lore.cpp
+++ b/src/view/display-lore.cpp
@@ -52,7 +52,7 @@ void roff_top(MONRACE_IDX r_idx)
 
 #ifdef JP
 #else
-    if (!(r_ptr->flags1 & RF1_UNIQUE)) {
+    if (r_ptr->kind_flags.has_not(MonsterKindType::UNIQUE)) {
         term_addstr(-1, TERM_WHITE, "The ");
     }
 #endif
@@ -126,7 +126,7 @@ void output_monster_spoiler(MONRACE_IDX r_idx, void (*roff_func)(TERM_COLOR attr
 
 static bool display_kill_unique(lore_type *lore_ptr)
 {
-    if ((lore_ptr->flags1 & RF1_UNIQUE) == 0)
+    if (lore_ptr->kind_flags.has_not(MonsterKindType::UNIQUE))
         return false;
 
     bool dead = (lore_ptr->r_ptr->max_num == 0);
@@ -344,33 +344,33 @@ void display_monster_never_move(lore_type *lore_ptr)
 
 void display_monster_kind(lore_type *lore_ptr)
 {
-    if (((lore_ptr->flags3 & (RF3_DRAGON | RF3_DEMON | RF3_GIANT | RF3_TROLL | RF3_ORC | RF3_ANGEL)) == 0) && ((lore_ptr->flags2 & (RF2_QUANTUM | RF2_HUMAN)) == 0)) {
+    if (lore_ptr->kind_flags.has_none_of({ MonsterKindType::DRAGON, MonsterKindType::DEMON, MonsterKindType::GIANT, MonsterKindType::TROLL, MonsterKindType::ORC, MonsterKindType::ANGEL, MonsterKindType::QUANTUM, MonsterKindType::HUMAN })) {
         hooked_roff(_("モンスター", " creature"));
         return;
     }
 
-    if (lore_ptr->flags3 & RF3_DRAGON)
+    if (lore_ptr->kind_flags.has(MonsterKindType::DRAGON))
         hook_c_roff(TERM_ORANGE, _("ドラゴン", " dragon"));
 
-    if (lore_ptr->flags3 & RF3_DEMON)
+    if (lore_ptr->kind_flags.has(MonsterKindType::DEMON))
         hook_c_roff(TERM_VIOLET, _("デーモン", " demon"));
 
-    if (lore_ptr->flags3 & RF3_GIANT)
+    if (lore_ptr->kind_flags.has(MonsterKindType::GIANT))
         hook_c_roff(TERM_L_UMBER, _("巨人", " giant"));
 
-    if (lore_ptr->flags3 & RF3_TROLL)
+    if (lore_ptr->kind_flags.has(MonsterKindType::TROLL))
         hook_c_roff(TERM_BLUE, _("トロル", " troll"));
 
-    if (lore_ptr->flags3 & RF3_ORC)
+    if (lore_ptr->kind_flags.has(MonsterKindType::ORC))
         hook_c_roff(TERM_UMBER, _("オーク", " orc"));
 
-    if (lore_ptr->flags2 & RF2_HUMAN)
+    if (lore_ptr->kind_flags.has(MonsterKindType::HUMAN))
         hook_c_roff(TERM_L_WHITE, _("人間", " human"));
 
-    if (lore_ptr->flags2 & RF2_QUANTUM)
+    if (lore_ptr->kind_flags.has(MonsterKindType::QUANTUM))
         hook_c_roff(TERM_VIOLET, _("量子生物", " quantum creature"));
 
-    if (lore_ptr->flags3 & RF3_ANGEL)
+    if (lore_ptr->kind_flags.has(MonsterKindType::ANGEL))
         hook_c_roff(TERM_YELLOW, _("天使", " angel"));
 }
 
@@ -379,19 +379,19 @@ void display_monster_alignment(lore_type *lore_ptr)
     if (lore_ptr->flags2 & RF2_ELDRITCH_HORROR)
         hook_c_roff(TERM_VIOLET, _("狂気を誘う", " sanity-blasting"));
 
-    if (lore_ptr->flags3 & RF3_ANIMAL)
+    if (lore_ptr->kind_flags.has(MonsterKindType::ANIMAL))
         hook_c_roff(TERM_L_GREEN, _("自然界の", " natural"));
 
-    if (lore_ptr->flags3 & RF3_EVIL)
+    if (lore_ptr->kind_flags.has(MonsterKindType::EVIL))
         hook_c_roff(TERM_L_DARK, _("邪悪なる", " evil"));
 
-    if (lore_ptr->flags3 & RF3_GOOD)
+    if (lore_ptr->kind_flags.has(MonsterKindType::GOOD))
         hook_c_roff(TERM_YELLOW, _("善良な", " good"));
 
-    if (lore_ptr->flags3 & RF3_UNDEAD)
+    if (lore_ptr->kind_flags.has(MonsterKindType::UNDEAD))
         hook_c_roff(TERM_VIOLET, _("アンデッドの", " undead"));
 
-    if (lore_ptr->flags3 & RF3_AMBERITE)
+    if (lore_ptr->kind_flags.has(MonsterKindType::AMBERITE))
         hook_c_roff(TERM_VIOLET, _("アンバーの王族の", " Amberite"));
 }
 
@@ -479,7 +479,7 @@ void display_lore_this(PlayerType *player_ptr, lore_type *lore_ptr)
 #ifdef JP
     hooked_roff("この");
 #else
-    if (lore_ptr->flags1 & RF1_UNIQUE) {
+    if (lore_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         hooked_roff("Killing this");
     } else {
         hooked_roff("A kill of this");
@@ -514,7 +514,7 @@ static void display_monster_escort_contents(lore_type *lore_ptr)
             continue;
 
         monster_race *rf_ptr = &r_info[lore_ptr->r_ptr->reinforce_id[n]];
-        if (rf_ptr->flags1 & RF1_UNIQUE) {
+        if (rf_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             hooked_roff(format(_("、%s", ", %s"), rf_ptr->name.c_str()));
             continue;
         }

diff --git a/src/window/display-sub-windows.cpp b/src/window/display-sub-windows.cpp
index 7ad9085..e7304c4 100644 (file)
--- a/src/window/display-sub-windows.cpp
+++ b/src/window/display-sub-windows.cpp
@@ -108,7 +108,7 @@ static void print_monster_line(TERM_LEN x, TERM_LEN y, monster_type *m_ptr, int
     term_gotoxy(x, y);
     if (!r_ptr)
         return;
-    if (r_ptr->flags1 & RF1_UNIQUE) {
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
         bool is_bounty = false;
         for (int i = 0; i < MAX_BOUNTY; i++) {
             if (w_ptr->bounty_r_idx[i] == r_idx) {

diff --git a/src/wizard/monster-info-spoiler.cpp b/src/wizard/monster-info-spoiler.cpp
index af10cee..6f306a2 100644 (file)
--- a/src/wizard/monster-info-spoiler.cpp
+++ b/src/wizard/monster-info-spoiler.cpp
@@ -124,7 +124,7 @@ SpoilerOutputResultType spoil_mon_desc(concptr fname, std::function<bool(const m
             continue;
         }
 
-        if (any_bits(r_ptr->flags1, RF1_UNIQUE)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             sprintf(nam, "[U] %s", name_buf);
         } else if (any_bits(r_ptr->flags7, RF7_NAZGUL)) {
             sprintf(nam, "[N] %s", name_buf);
@@ -206,8 +206,7 @@ SpoilerOutputResultType spoil_mon_info(concptr fname)
     ang_sort(&dummy, who.data(), &why, who.size(), ang_sort_comp_hook, ang_sort_swap_hook);
     for (auto r_idx : who) {
         auto *r_ptr = &r_info[r_idx];
-        BIT_FLAGS flags1 = r_ptr->flags1;
-        if (any_bits(flags1, RF1_UNIQUE)) {
+        if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE)) {
             spoil_out("[U] ");
         } else if (any_bits(r_ptr->flags7, RF7_NAZGUL)) {
             spoil_out("[N] ");
@@ -233,7 +232,7 @@ SpoilerOutputResultType spoil_mon_info(concptr fname)
         }
 
         spoil_out(buf);
-        if (any_bits(flags1, RF1_FORCE_MAXHP) || (r_ptr->hside == 1)) {
+        if (any_bits(r_ptr->flags1, RF1_FORCE_MAXHP) || (r_ptr->hside == 1)) {
             sprintf(buf, "Hp:%d  ", r_ptr->hdice * r_ptr->hside);
         } else {
             sprintf(buf, "Hp:%dd%d  ", r_ptr->hdice, r_ptr->hside);

diff --git a/src/wizard/wizard-game-modifier.cpp b/src/wizard/wizard-game-modifier.cpp
index 7addc1b..6ba5f0e 100644 (file)
--- a/src/wizard/wizard-game-modifier.cpp
+++ b/src/wizard/wizard-game-modifier.cpp
@@ -164,7 +164,7 @@ void wiz_restore_monster_max_num()
     }
 
     MONSTER_NUMBER n = 0;
-    if (any_bits(r_ptr->flags1, RF1_UNIQUE))
+    if (r_ptr->kind_flags.has(MonsterKindType::UNIQUE))
         n = 1;
     else if (any_bits(r_ptr->flags7, RF7_NAZGUL))
         n = MAX_NAZGUL_NUM;