bool return_when_thrown;
GAME_TEXT o_name[MAX_NLEN];
int msec;
- BIT_FLAGS obj_flags[TR_FLAG_SIZE];
+ TrFlags obj_flags;
bool come_back;
bool do_drop;
grid_type *g_ptr;
/*対邪平均ダメージの計算処理*/
static HIT_POINT calc_arm_avgdamage(player_type *player_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
HIT_POINT base, forced, vorpal;
HIT_POINT s_evil = forced = vorpal = 0;
bool has_extreme_damage_rate(player_type *player_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
if (has_flag(flgs, TR_VAMPIRIC)) {
if (has_flag(flgs, TR_BLOWS) && (o_ptr->pval == 1) && (calc_arm_avgdamage(player_ptr, o_ptr) > 52)) {
{
KIND_OBJECT_IDX k_idx = lookup_kind(o_ptr->tval, o_ptr->sval);
object_kind *k_ptr = &k_info[k_idx];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
if (has_flag(flgs, TR_KILL_EVIL)) {
if (!o_ptr)
return;
- BIT_FLAGS flgs[TR_FLAG_SIZE], flgs2[TR_FLAG_SIZE];
+ TrFlags flgs, flgs2;
object_flags(user_ptr, o_ptr, flgs);
PlayerEnergy(user_ptr).set_player_turn_energy(50);
if (!o_ptr)
return;
- BIT_FLAGS flgs[TR_FLAG_SIZE], flgs2[TR_FLAG_SIZE];
+ TrFlags flgs, flgs2;
object_flags(user_ptr, o_ptr, flgs);
PlayerEnergy(user_ptr).set_player_turn_energy(50);
bool observe = false;
int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2;
TIME_EFFECT old_timeout;
- BIT_FLAGS old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
+ TrFlags old_flgs, new_flgs;
object_type *o_ptr;
concptr q, s;
POSITION iy, ix;
concptr q, s;
object_type *o_ptr;
GAME_TEXT o_name[MAX_NLEN];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
item_tester_hook = object_is_smith;
monster_race *race_ptr = &r_info[monster_ptr->r_idx];
- BIT_FLAGS flags[TR_FLAG_SIZE], bow_flags[TR_FLAG_SIZE], arrow_flags[TR_FLAG_SIZE];
+ TrFlags flags, bow_flags, arrow_flags;
object_flags(sniper_ptr, arrow_ptr, arrow_flags);
object_flags(sniper_ptr, bow_ptr, bow_flags);
* @param m_ptr 目標モンスターの構造体参照ポインタ
* @return スレイング加味後の倍率(/10倍)
*/
-MULTIPLY mult_slaying(player_type *player_ptr, MULTIPLY mult, const BIT_FLAGS *flgs, monster_type *m_ptr)
+MULTIPLY mult_slaying(player_type *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr)
{
static const struct slay_table_t {
int slay_flag;
* @param m_ptr 目標モンスターの構造体参照ポインタ
* @return スレイング加味後の倍率(/10倍)
*/
-MULTIPLY mult_brand(player_type *player_ptr, MULTIPLY mult, const BIT_FLAGS *flgs, monster_type *m_ptr)
+MULTIPLY mult_brand(player_type *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr)
{
static const struct brand_table_t {
int brand_flag;
*/
HIT_POINT calc_attack_damage_with_slay(player_type *attacker_ptr, object_type *o_ptr, HIT_POINT tdam, monster_type *m_ptr, combat_options mode, bool thrown)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(attacker_ptr, o_ptr, flgs);
torch_flags(o_ptr, flgs); /* torches has secret flags */
typedef struct monster_type monster_type;
typedef struct object_type object_type;
typedef struct player_type player_type;
-MULTIPLY mult_slaying(player_type *player_ptr, MULTIPLY mult, const BIT_FLAGS *flgs, monster_type *m_ptr);
-MULTIPLY mult_brand(player_type *player_ptr, MULTIPLY mult, const BIT_FLAGS *flgs, monster_type *m_ptr);
+MULTIPLY mult_slaying(player_type *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr);
+MULTIPLY mult_brand(player_type *player_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr);
HIT_POINT calc_attack_damage_with_slay(player_type *attacker_ptr, object_type *o_ptr, HIT_POINT tdam, monster_type *m_ptr, combat_options mode, bool thrown);
#else
bool plural = (o_ptr->number > 1);
#endif
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
object_flags(caster_ptr, o_ptr, flags);
bool is_artifact = object_is_artifact(o_ptr);
switch (typ) {
if (!(flavor_ptr->mode & OD_DEBUG)) {
num_fire = calc_num_fire(player_ptr, flavor_ptr->o_ptr);
} else {
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, flavor_ptr->o_ptr, flgs);
if (has_flag(flgs, TR_XTRA_SHOTS))
num_fire += 100;
* sprintf(t, "%+d", n), and return a pointer to the terminator.
* Note that we always print a sign, either "+" or "-".
*/
-static char *inscribe_flags_aux(std::vector<flag_insc_table>& fi_vec, BIT_FLAGS flgs[TR_FLAG_SIZE], bool kanji, char *ptr)
+static char *inscribe_flags_aux(std::vector<flag_insc_table> &fi_vec, const TrFlags &flgs, bool kanji, char *ptr)
{
#ifdef JP
#else
* @param flgs 対応するオブジェクトのフラグ文字列
* @return 1つでも該当の特性があったらTRUEを返す。
*/
-static bool has_flag_of(std::vector<flag_insc_table>& fi_vec, BIT_FLAGS flgs[TR_FLAG_SIZE])
+static bool has_flag_of(std::vector<flag_insc_table> &fi_vec, const TrFlags &flgs)
{
for (flag_insc_table &fi : fi_vec)
if (has_flag(flgs, fi.flag) && (fi.except_flag == -1 || !has_flag(flgs, fi.except_flag)))
char *get_ability_abbreviation(player_type *player_ptr, char *short_flavor, object_type *o_ptr, bool kanji, bool all)
{
char *prev_ptr = short_flavor;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
if (!all) {
object_kind *k_ptr = &k_info[o_ptr->k_idx];
}
#endif
-bool has_lite_flag(BIT_FLAGS *flags) { return has_flag(flags, TR_LITE_1) || has_flag(flags, TR_LITE_2) || has_flag(flags, TR_LITE_3); }
+bool has_lite_flag(const TrFlags &flags)
+{
+ return has_flag(flags, TR_LITE_1) || has_flag(flags, TR_LITE_2) || has_flag(flags, TR_LITE_3);
+}
-bool has_dark_flag(BIT_FLAGS *flags) { return has_flag(flags, TR_LITE_M1) || has_flag(flags, TR_LITE_M2) || has_flag(flags, TR_LITE_M3); }
+bool has_dark_flag(const TrFlags &flags)
+{
+ return has_flag(flags, TR_LITE_M1) || has_flag(flags, TR_LITE_M2) || has_flag(flags, TR_LITE_M3);
+}
char tmp_val[MAX_NLEN + 160];
char tmp_val2[MAX_NLEN + 10];
char fake_insc_buf[30];
- BIT_FLAGS tr_flags[TR_FLAG_SIZE];
+ TrFlags tr_flags;
object_type *bow_ptr;
object_kind *k_ptr;
object_kind *flavor_k_ptr;
char *object_desc_int(char *t, int v);
char *get_ability_abbreviation(player_type *player_ptr, char *ptr, object_type *o_ptr, bool kanji, bool all);
void get_inscription(player_type *player_ptr, char *buff, object_type *o_ptr);
-bool has_lite_flag(BIT_FLAGS *flags);
-bool has_dark_flag(BIT_FLAGS *flags);
+bool has_lite_flag(const TrFlags &flags);
+bool has_dark_flag(const TrFlags &flags);
#ifdef JP
char *object_desc_count_japanese(char *t, object_type *o_ptr);
object_type *o_ptr;
o_ptr = &creature_ptr->inventory_list[INVEN_LITE];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(creature_ptr, o_ptr, flgs);
if (creature_ptr->inventory_list[INVEN_LITE].tval && !has_flag(flgs, TR_DARK_SOURCE) && !has_resist_lite(creature_ptr)) {
return;
tr_type cf = TR_STR;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(creature_ptr, o_ptr, flgs);
switch (flag) {
case TRC::ADD_L_CURSE:
object_type *o_ptr;
int i_keep = 0, count = 0;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
o_ptr = &creature_ptr->inventory_list[i];
if (!o_ptr->k_idx)
continue;
* @param flags 耐性配列へのポインタ
* @param fff 一時ファイルへのポインタ
*/
-static void print_im_or_res_flag(int immunity, int resistance, BIT_FLAGS *flags, FILE *fff)
+static void print_im_or_res_flag(int immunity, int resistance, const TrFlags &flags, FILE *fff)
{
fputs(has_flag(flags, immunity) ? IM_FLAG_STR : (has_flag(flags, resistance) ? HAS_FLAG_STR : NO_FLAG_STR), fff);
}
* @param flags 耐性配列へのポインタ
* @param fff 一時ファイルへのポインタ
*/
-static void print_flag(int tr, BIT_FLAGS *flags, FILE *fff) { fputs(has_flag(flags, tr) ? HAS_FLAG_STR : NO_FLAG_STR, fff); }
+static void print_flag(int tr, const TrFlags &flags, FILE *fff)
+{
+ fputs(has_flag(flags, tr) ? HAS_FLAG_STR : NO_FLAG_STR, fff);
+}
/*!
* @brief 特殊なアイテムかどうかを調べる
*/
static void display_identified_resistances_flag(player_type *creature_ptr, object_type *o_ptr, FILE *fff)
{
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
object_flags_known(creature_ptr, o_ptr, flags);
print_im_or_res_flag(TR_IM_ACID, TR_RES_ACID, flags, fff);
if (!h_older_than(2, 1, 2, 4))
return;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
if ((o_ptr->name2 == EGO_DARK) || (o_ptr->name2 == EGO_ANCIENT_CURSE) || (o_ptr->name1 == ART_NIGHT)) {
*/
static void give_one_ability_of_object(player_type *player_ptr, object_type *to_ptr, object_type *from_ptr)
{
- BIT_FLAGS to_flgs[TR_FLAG_SIZE];
- BIT_FLAGS from_flgs[TR_FLAG_SIZE];
+ TrFlags to_flgs;
+ TrFlags from_flgs;
object_flags(player_ptr, to_ptr, to_flgs);
object_flags(player_ptr, from_ptr, from_flgs);
*/
static void compare_weapon_aux(player_type *owner_ptr, object_type *o_ptr, int col, int r)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
int blow = owner_ptr->num_blow[0];
bool force = false;
bool dokubari = false;
GAME_TEXT o_name[MAX_NLEN];
describe_flavor(caster_ptr, o_name, o_ptr, OD_OMIT_PREFIX | OD_NAME_ONLY);
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(caster_ptr, o_ptr, flgs);
if (object_is_cursed(o_ptr)) {
typedef struct samurai_slaying_type {
MULTIPLY mult;
- BIT_FLAGS *flags;
+ TrFlags flags;
monster_type *m_ptr;
combat_options mode;
monster_race *r_ptr;
} samurai_slaying_type;
static samurai_slaying_type *initialize_samurai_slaying_type(
- samurai_slaying_type *samurai_slaying_ptr, MULTIPLY mult, BIT_FLAGS *flags, monster_type *m_ptr, combat_options mode, monster_race *r_ptr)
+ samurai_slaying_type *samurai_slaying_ptr, MULTIPLY mult, const TrFlags &flags, monster_type *m_ptr, combat_options mode, monster_race *r_ptr)
{
samurai_slaying_ptr->mult = mult;
- samurai_slaying_ptr->flags = flags;
+ std::copy_n(flags, TR_FLAG_SIZE, samurai_slaying_ptr->flags);
samurai_slaying_ptr->m_ptr = m_ptr;
samurai_slaying_ptr->mode = mode;
samurai_slaying_ptr->r_ptr = r_ptr;
* @param mode 剣術のスレイ型ID
* @return スレイの倍率(/10倍)
*/
-MULTIPLY mult_hissatsu(player_type *attacker_ptr, MULTIPLY mult, BIT_FLAGS *flags, monster_type *m_ptr, combat_options mode)
+MULTIPLY mult_hissatsu(player_type *attacker_ptr, MULTIPLY mult, const TrFlags &flags, monster_type *m_ptr, combat_options mode)
{
monster_race *r_ptr = &r_info[m_ptr->r_idx];
samurai_slaying_type tmp_slaying;
typedef struct monster_type monster_type;
typedef struct player_attack_type player_attack_type;
typedef struct player_type player_type;
-MULTIPLY mult_hissatsu(player_type *attacker_ptr, MULTIPLY mult, BIT_FLAGS *flgs, monster_type *m_ptr, combat_options mode);
+MULTIPLY mult_hissatsu(player_type *attacker_ptr, MULTIPLY mult, const TrFlags &flgs, monster_type *m_ptr, combat_options mode);
void concentration(player_type *creature_ptr);
bool choose_kata(player_type* creature_ptr);
int calc_attack_quality(player_type *attacker_ptr, player_attack_type *pa_ptr);
/*!
* @brief オブジェクトのフラグを更新する
*/
-static void update_object_flags(BIT_FLAGS *flgs, BIT_FLAGS *flg2, BIT_FLAGS *flg3, BIT_FLAGS *flgr)
+static void update_object_flags(const TrFlags &flgs, BIT_FLAGS *flg2, BIT_FLAGS *flg3, BIT_FLAGS *flgr)
{
if (has_flag(flgs, TR_SLAY_DRAGON))
*flg3 |= (RF3_DRAGON);
turn_flags_ptr->do_take = (r_ptr->flags2 & RF2_TAKE_ITEM) != 0;
for (auto it = g_ptr->o_idx_list.begin(); it != g_ptr->o_idx_list.end();) {
- BIT_FLAGS flgs[TR_FLAG_SIZE], flg2 = 0L, flg3 = 0L, flgr = 0L;
+ TrFlags flgs;
+ BIT_FLAGS flg2 = 0L, flg3 = 0L, flgr = 0L;
GAME_TEXT m_name[MAX_NLEN], o_name[MAX_NLEN];
OBJECT_IDX this_o_idx = *it++;
object_type *o_ptr = &target_ptr->current_floor_ptr->o_list[this_o_idx];
if (!get_aim_dir(user_ptr, &dir))
return false;
- BIT_FLAGS resistance_flags[TR_FLAG_SIZE];
+ TrFlags resistance_flags;
object_flags(user_ptr, o_ptr, resistance_flags);
int type[20];
object_type *o_ptr = &owner_ptr->inventory_list[INVEN_MAIN_HAND + randint0(12)];
if (!o_ptr->k_idx)
return;
- BIT_FLAGS oflgs[TR_FLAG_SIZE];
+ TrFlags oflgs;
object_flags(owner_ptr, o_ptr, oflgs);
GAME_TEXT o_name[MAX_NLEN];
describe_flavor(owner_ptr, o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
PRICE cost{}; //!< コスト
- BIT_FLAGS flags[TR_FLAG_SIZE]{}; //!< 能力/耐性フラグ
+ TrFlags flags{}; //!< 能力/耐性フラグ
EnumClassFlagGroup<TRG> gen_flags; //!< 生成時適用フラグ
std::vector<ego_generate_type> xtra_flags{}; //!< 追加能力/耐性フラグ
/* Unused */
(void)player_ptr;
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
if (!object_is_known(o_ptr))
return false;
/* Unused */
(void)player_ptr;
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
if (o_ptr->tval == player_ptr->tval_ammo)
return true;
/* Favorite weapons are varied depend on the class */
switch (player_ptr->pclass) {
case CLASS_PRIEST: {
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags_known(player_ptr, o_ptr, flgs);
if (!has_flag(flgs, TR_BLESSED) && !(o_ptr->tval == TV_HAFTED))
case CLASS_BEASTMASTER:
case CLASS_CAVALRY: {
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags_known(player_ptr, o_ptr, flgs);
/* Is it known to be suitable to using while riding? */
*/
int set_acid_destroy(player_type *owner_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
if (!hates_acid(o_ptr))
return false;
object_flags(owner_ptr, o_ptr, flgs);
*/
int set_elec_destroy(player_type *owner_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
if (!hates_elec(o_ptr))
return false;
object_flags(owner_ptr, o_ptr, flgs);
*/
int set_fire_destroy(player_type *owner_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
if (!hates_fire(o_ptr))
return false;
object_flags(owner_ptr, o_ptr, flgs);
*/
int set_cold_destroy(player_type *owner_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
if (!hates_cold(o_ptr))
return false;
object_flags(owner_ptr, o_ptr, flgs);
* @param o_ptr フラグ取得元のオブジェクト構造体ポインタ
* @param flgs フラグ情報を受け取る配列
*/
-void object_flags(player_type *player_ptr, object_type *o_ptr, BIT_FLAGS flgs[TR_FLAG_SIZE])
+void object_flags(player_type *player_ptr, object_type *o_ptr, TrFlags &flgs)
{
object_kind *k_ptr = &k_info[o_ptr->k_idx];
* @param o_ptr フラグ取得元のオブジェクト構造体ポインタ
* @param flgs フラグ情報を受け取る配列
*/
-void object_flags_known(player_type *player_ptr, object_type *o_ptr, BIT_FLAGS flgs[TR_FLAG_SIZE])
+void object_flags_known(player_type *player_ptr, object_type *o_ptr, TrFlags &flgs)
{
bool spoil = false;
object_kind *k_ptr = &k_info[o_ptr->k_idx];
typedef struct object_type object_type;
typedef struct player_type player_type;
-void object_flags(player_type *player_ptr, object_type *o_ptr, BIT_FLAGS flgs[TR_FLAG_SIZE]);
-void object_flags_known(player_type *player_ptr, object_type *o_ptr, BIT_FLAGS flgs[TR_FLAG_SIZE]);
+void object_flags(player_type *player_ptr, object_type *o_ptr, TrFlags &flgs);
+void object_flags_known(player_type *player_ptr, object_type *o_ptr, TrFlags &flgs);
static concptr item_activation_dragon_breath(player_type *owner_ptr, object_type *o_ptr)
{
static char desc[256];
- BIT_FLAGS flgs[TR_FLAG_SIZE]; /* for resistance flags */
+ TrFlags flgs; /* for resistance flags */
int n = 0;
object_flags(owner_ptr, o_ptr, flgs);
*/
concptr activation_explanation(player_type *owner_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(owner_ptr, o_ptr, flgs);
if (!(has_flag(flgs, TR_ACTIVATE)))
return (_("なし", "nothing"));
PRICE cost{}; /*!< ベースアイテムの基本価値 / Object "base cost" */
- BIT_FLAGS flags[TR_FLAG_SIZE]{}; /*!< ベースアイテムの基本特性ビット配列 / Flags */
+ TrFlags flags{}; /*!< ベースアイテムの基本特性ビット配列 / Flags */
EnumClassFlagGroup<TRG> gen_flags; /*!< ベースアイテムの生成特性ビット配列 / flags for generate */
PRICE flag_cost(player_type *player_ptr, object_type *o_ptr, int plusses)
{
PRICE total = 0;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_kind *k_ptr = &k_info[o_ptr->k_idx];
object_flags(player_ptr, o_ptr, flgs);
*/
PRICE object_value_real(player_type *player_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_kind *k_ptr = &k_info[o_ptr->k_idx];
if (!k_info[o_ptr->k_idx].cost)
/* Search Inventory */
int number = 0;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_type *o_ptr = &creature_ptr->inventory_list[i];
object_flags(creature_ptr, o_ptr, flgs);
*/
bool screen_object(player_type *player_ptr, object_type *o_ptr, BIT_FLAGS mode)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
char temp[70 * 20];
concptr info[128];
GAME_TEXT o_name[MAX_NLEN];
const martial_arts *ma_ptr{}; //!< マーシャルアーツ種別
HIT_POINT attack_damage{}; //!< 累積ダメージ
int num_blow{}; //!< 打撃回数
- BIT_FLAGS flags[TR_FLAG_SIZE]{}; //!< 武器フラグ
+ TrFlags flags{}; //!< 武器フラグ
chaotic_effect chaos_effect{}; //!< カオス効果
MagicalBrandEffect magical_effect{}; //!< 魔術効果
bool *fear{}; //!< 恐怖したかどうか
void set_equipment_influence(player_type *creature_ptr, self_info_type *self_ptr)
{
for (int k = INVEN_MAIN_HAND; k < INVEN_TOTAL; k++) {
- uint32_t tflgs[TR_FLAG_SIZE];
+ TrFlags tflgs;
object_type *o_ptr = &creature_ptr->inventory_list[k];
if (o_ptr->k_idx == 0)
continue;
int line;
char v_string[8][128];
char s_string[6][128];
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
char plev_buf[80];
char buf[2][80];
concptr info[220];
BIT_FLAGS PlayerStatusBase::equipments_flags(tr_type check_flag)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
BIT_FLAGS result = 0L;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &owner_ptr->inventory_list[i];
BIT_FLAGS PlayerStatusBase::equipments_bad_flags(tr_type check_flag)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
BIT_FLAGS result = 0L;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &owner_ptr->inventory_list[i];
int16_t result = 0;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *o_ptr = &owner_ptr->inventory_list[i];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(owner_ptr, o_ptr, flgs);
if (!o_ptr->k_idx)
* @param flags 耐性フラグの配列
* @todo 最終的にplayer-status系列と統合する
*/
-static void add_class_flags(player_type *creature_ptr, BIT_FLAGS *flags)
+static void add_class_flags(player_type *creature_ptr, TrFlags &flags)
{
switch (creature_ptr->pclass) {
case CLASS_WARRIOR: {
* @param flags 耐性フラグの配列
* @todo 最終的にplayer-status系列と統合する
*/
-static void add_mutation_flags(player_type *creature_ptr, BIT_FLAGS *flags)
+static void add_mutation_flags(player_type *creature_ptr, TrFlags &flags)
{
if (creature_ptr->muta.none())
return;
* @param flags 耐性フラグの配列
* @todo 最終的にplayer-status系列と統合する
*/
-static void add_personality_flags(player_type *creature_ptr, BIT_FLAGS *flags)
+static void add_personality_flags(player_type *creature_ptr, TrFlags &flags)
{
if (creature_ptr->pseikaku == PERSONALITY_SEXY)
add_flag(flags, TR_AGGRAVATE);
* @param flags 耐性フラグの配列
* @todo 最終的にplayer-status系列と統合する
*/
-static void add_kata_flags(player_type *creature_ptr, BIT_FLAGS *flags)
+static void add_kata_flags(player_type *creature_ptr, TrFlags &flags)
{
if (creature_ptr->special_defense & KATA_FUUJIN)
add_flag(flags, TR_REFLECT);
* Obtain the "flags" for the player as if he was an item
* @todo 最終的にplayer-status系列と統合する
*/
-void player_flags(player_type *creature_ptr, BIT_FLAGS *flags)
+void player_flags(player_type *creature_ptr, TrFlags &flags)
{
for (int i = 0; i < TR_FLAG_SIZE; i++)
flags[i] = 0L;
add_kata_flags(creature_ptr, flags);
}
-void riding_flags(player_type *creature_ptr, BIT_FLAGS *flags, BIT_FLAGS *negative_flags)
+void riding_flags(player_type *creature_ptr, TrFlags &flags, TrFlags &negative_flags)
{
for (int i = 0; i < TR_FLAG_SIZE; i++) {
flags[i] = 0L;
#include "system/angband.h"
typedef struct player_type player_type;
-void player_flags(player_type *creature_ptr, BIT_FLAGS *flags);
-void riding_flags(player_type *creature_ptr, BIT_FLAGS *flags, BIT_FLAGS *negative_flags);
+void player_flags(player_type *creature_ptr, TrFlags &flags);
+void riding_flags(player_type *creature_ptr, TrFlags &flags, TrFlags &negative_flags);
GAME_TEXT o_name[MAX_NLEN];
describe_flavor(creature_ptr, o_name, o_ptr, OD_OMIT_PREFIX | OD_NAME_ONLY);
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(creature_ptr, o_ptr, flgs);
if (o_ptr->ac + o_ptr->to_a <= 0) {
msg_format(_("%sは既にボロボロだ!", "Your %s is already fully corroded!"), o_name);
* @param flags フラグ配列へのポインタ
* @param base_race ベース種族の情報を返すならtrue、ミミック擬態中の種族を返すならfalse
*/
-void add_player_race_flags(player_type *creature_ptr, BIT_FLAGS *flags, bool base_race)
+void add_player_race_flags(player_type *creature_ptr, TrFlags &flags, bool base_race)
{
auto race_ptr = get_player_race_info(creature_ptr, base_race);
if (race_ptr->infra > 0)
SYMBOL_CODE get_summon_symbol_from_player(player_type *creature_ptr);
bool is_specific_player_race(player_type *creature_ptr, player_race_type prace);
bool player_race_has_flag(player_type *creature_ptr, tr_type flag, bool base_race = false);
-void add_player_race_flags(player_type *creature_ptr, BIT_FLAGS *flags, bool base_race = false);
+void add_player_race_flags(player_type *creature_ptr, TrFlags &flags, bool base_race = false);
PlayerRaceLife player_race_life(player_type *creature_ptr, bool base_race = false);
PlayerRaceFood player_race_food(player_type *creature_ptr, bool base_race = false);
BIT_FLAGS check_equipment_flags(player_type *creature_ptr, tr_type tr_flag)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
BIT_FLAGS result = 0L;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &creature_ptr->inventory_list[i];
{
BIT_FLAGS result = 0L;
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &creature_ptr->inventory_list[i];
void update_curses(player_type *creature_ptr)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
creature_ptr->cursed.clear();
creature_ptr->cursed_special.clear();
void update_extra_blows(player_type *creature_ptr)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
creature_ptr->extra_blows[0] = creature_ptr->extra_blows[1] = 0;
const melee_type melee_type = player_melee_type(creature_ptr);
*/
bool has_icky_wield_weapon(player_type *creature_ptr, int i)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_type *o_ptr = &creature_ptr->inventory_list[INVEN_MAIN_HAND + i];
object_flags(creature_ptr, o_ptr, flgs);
bool has_riding_wield_weapon(player_type *creature_ptr, int i)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
o_ptr = &creature_ptr->inventory_list[INVEN_MAIN_HAND + i];
object_flags(creature_ptr, o_ptr, flgs);
if (creature_ptr->riding != 0 && !(o_ptr->tval == TV_POLEARM) && ((o_ptr->sval == SV_LANCE) || (o_ptr->sval == SV_HEAVY_LANCE))
}
if (any_bits(mp_ptr->spell_xtra, extra_magic_glove_reduce_mana)) {
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
creature_ptr->cumber_glove = false;
object_type *o_ptr;
o_ptr = &creature_ptr->inventory_list[INVEN_ARMS];
int16_t calc_num_fire(player_type *creature_ptr, object_type *o_ptr)
{
int extra_shots = 0;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *q_ptr;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
o_ptr = &creature_ptr->inventory_list[i];
if (!o_ptr->k_idx)
continue;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
o_ptr = &creature_ptr->inventory_list[i];
if (!o_ptr->k_idx)
continue;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
o_ptr = &creature_ptr->inventory_list[i];
if (!o_ptr->k_idx)
continue;
static ACTION_SKILL_POWER calc_skill_dig(player_type *creature_ptr)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
ACTION_SKILL_POWER pow;
static int16_t calc_num_blow(player_type *creature_ptr, int i)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
int16_t num_blow = 1;
o_ptr = &creature_ptr->inventory_list[INVEN_MAIN_HAND + i];
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
o_ptr = &creature_ptr->inventory_list[i];
if (!o_ptr->k_idx)
continue;
static ARMOUR_CLASS calc_to_ac(player_type *creature_ptr, bool is_real_value)
{
ARMOUR_CLASS ac = 0;
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
if (creature_ptr->yoiyami)
return 0;
int16_t calc_double_weapon_penalty(player_type *creature_ptr, INVENTORY_IDX slot)
{
int penalty = 0;
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
if (has_melee_weapon(creature_ptr, INVEN_MAIN_HAND) && has_melee_weapon(creature_ptr, INVEN_SUB_HAND)) {
object_flags(creature_ptr, &creature_ptr->inventory_list[INVEN_SUB_HAND], flags);
static int16_t calc_to_damage(player_type *creature_ptr, INVENTORY_IDX slot, bool is_real_value)
{
object_type *o_ptr = &creature_ptr->inventory_list[slot];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(creature_ptr, o_ptr, flgs);
player_hand calc_hand = PLAYER_HAND_OTHER;
/* Bonuses and penalties by weapon */
if (has_melee_weapon(creature_ptr, slot)) {
object_type *o_ptr = &creature_ptr->inventory_list[slot];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(creature_ptr, o_ptr, flgs);
int tval = o_ptr->tval - TV_WEAPON_BEGIN;
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
o_ptr = &creature_ptr->inventory_list[INVEN_BOW];
if (o_ptr->k_idx) {
object_flags(creature_ptr, o_ptr, flgs);
static int16_t calc_to_damage_misc(player_type *creature_ptr)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
int16_t to_dam = 0;
static int16_t calc_to_hit_misc(player_type *creature_ptr)
{
object_type *o_ptr;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
int16_t to_hit = 0;
* @todo
* xtra1.c周りと多重実装になっているのを何とかする
*/
-void player_immunity(player_type *creature_ptr, BIT_FLAGS *flags)
+void player_immunity(player_type *creature_ptr, TrFlags &flags)
{
for (int i = 0; i < TR_FLAG_SIZE; i++) {
flags[i] = 0L;
}
- if (player_race_has_flag(creature_ptr, TR_IM_ACID))
+ if (player_race_has_flag(creature_ptr, TR_IM_ACID))
add_flag(flags, TR_RES_ACID);
if (player_race_has_flag(creature_ptr, TR_IM_COLD))
add_flag(flags, TR_RES_COLD);
}
}
-
/*!
* @brief プレイヤーの一時的魔法効果による免疫フラグを返す
* @param creature_ptr プレーヤーへの参照ポインタ
* @todo
* xtra1.c周りと多重実装になっているのを何とかする
*/
-void tim_player_immunity(player_type *creature_ptr, BIT_FLAGS *flags)
+void tim_player_immunity(player_type *creature_ptr, TrFlags &flags)
{
for (int i = 0; i < TR_FLAG_SIZE; i++)
flags[i] = 0L;
* @todo
* xtra1.c周りと多重実装になっているのを何とかする
*/
-void known_obj_immunity(player_type *creature_ptr, BIT_FLAGS *flags)
+void known_obj_immunity(player_type *creature_ptr, TrFlags &flags)
{
for (int i = 0; i < TR_FLAG_SIZE; i++)
flags[i] = 0L;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++)
{
- uint32_t o_flags[TR_FLAG_SIZE];
+ TrFlags o_flags;
object_type *o_ptr;
o_ptr = &creature_ptr->inventory_list[i];
if (!o_ptr->k_idx) continue;
* @todo
* xtra1.c周りと多重実装になっているのを何とかする
*/
-void player_vulnerability_flags(player_type *creature_ptr, BIT_FLAGS *flags)
+void player_vulnerability_flags(player_type *creature_ptr, TrFlags &flags)
{
for (int i = 0; i < TR_FLAG_SIZE; i++)
flags[i] = 0L;
#include "system/angband.h"
typedef struct player_type player_type;
-void player_immunity(player_type *creature_ptr, BIT_FLAGS *flags);
-void tim_player_immunity(player_type *creature_ptr, BIT_FLAGS *flags);
-void known_obj_immunity(player_type *creature_ptr, BIT_FLAGS *flags);
-void player_vulnerability_flags(player_type *creature_ptr, BIT_FLAGS *flags);
+void player_immunity(player_type *creature_ptr, TrFlags &flags);
+void tim_player_immunity(player_type *creature_ptr, TrFlags &flags);
+void known_obj_immunity(player_type *creature_ptr, TrFlags &flags);
+void player_vulnerability_flags(player_type *creature_ptr, TrFlags &flags);
* @todo
* xtra1.c周りと多重実装になっているのを何とかする
*/
-void tim_player_flags(player_type *creature_ptr, BIT_FLAGS *flags)
+void tim_player_flags(player_type *creature_ptr, TrFlags &flags)
{
BIT_FLAGS tmp_effect_flag = FLAG_CAUSE_MAGIC_TIME_EFFECT;
set_bits(tmp_effect_flag, FLAG_CAUSE_BATTLE_FORM);
#include "system/angband.h"
typedef struct player_type player_type;
-void tim_player_flags(player_type *creature_ptr, BIT_FLAGS *flags);
+void tim_player_flags(player_type *creature_ptr, TrFlags &flags);
concptr q, s;
GAME_TEXT o_name[MAX_NLEN];
object_type *o_ptr;
- uint32_t f[TR_FLAG_SIZE];
+ TrFlags f;
item_tester_hook = item_tester_hook_weapon_except_bow;
q = _("どれを呪いますか?", "Which weapon do you curse?");
concptr q, s;
GAME_TEXT o_name[MAX_NLEN];
object_type *o_ptr;
- uint32_t f[TR_FLAG_SIZE];
+ TrFlags f;
item_tester_hook = object_is_armour;
q = _("どれを呪いますか?", "Which piece of armour do you curse?");
if (cast) {
OBJECT_IDX item;
concptr s, q;
- uint32_t f[TR_FLAG_SIZE];
+ TrFlags f;
object_type *o_ptr;
item_tester_hook = item_tester_hook_cursed;
if (cast) {
int total_damage = 0, basedam, i;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_type *o_ptr;
if (!get_aim_dir(caster_ptr, &dir))
return NULL;
if (cast) {
int total_damage = 0, basedam, i;
POSITION y, x;
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_type *o_ptr;
if (!get_direction(caster_ptr, &dir, false, false))
* @param magnification ダメージ倍率
* @param death_scythe_flags 死の大鎌に関するオブジェクトフラグ配列
*/
-static void compensate_death_scythe_reflection_magnification(player_type *attacker_ptr, int *magnification, BIT_FLAGS *death_scythe_flags)
+static void compensate_death_scythe_reflection_magnification(player_type *attacker_ptr, int *magnification, const TrFlags &death_scythe_flags)
{
if ((attacker_ptr->alignment < 0) && (*magnification < 20))
*magnification = 20;
*/
void process_death_scythe_reflection(player_type *attacker_ptr, player_attack_type *pa_ptr)
{
- BIT_FLAGS death_scythe_flags[TR_FLAG_SIZE];
+ TrFlags death_scythe_flags;
sound(SOUND_HIT);
msg_format(_("ミス! %sにかわされた。", "You miss %s."), pa_ptr->m_name);
msg_print(_("振り回した大鎌が自分自身に返ってきた!", "Your scythe returns to you!"));
* @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
* @param flgs 特別に追加するフラグを返す参照ポインタ
*/
-void torch_flags(object_type *o_ptr, BIT_FLAGS *flgs)
+void torch_flags(object_type *o_ptr, TrFlags &flgs)
{
if ((o_ptr->tval != TV_LITE) || (o_ptr->sval != SV_LITE_TORCH) || (o_ptr->xtra4 <= 0))
return;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *o_ptr;
o_ptr = &creature_ptr->inventory_list[i];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(creature_ptr, o_ptr, flgs);
if (!o_ptr->k_idx)
typedef struct object_type object_type;
typedef struct player_type player_type;
-void torch_flags(object_type *o_ptr, BIT_FLAGS *flgs);
+void torch_flags(object_type *o_ptr, TrFlags &flgs);
void torch_dice(object_type *o_ptr, DICE_NUMBER *dd, DICE_SID *ds);
void torch_lost_fuel(object_type *o_ptr);
void update_lite_radius(player_type *creature_ptr);
if (tracer_ptr->muta.has(MUTA::VTELEPORT) || (tracer_ptr->pclass == CLASS_IMITATOR))
follow = true;
else {
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_type *o_ptr;
INVENTORY_IDX i;
GAME_TEXT o_name[MAX_NLEN];
describe_flavor(caster_ptr, o_name, o_ptr, OD_OMIT_PREFIX | OD_NAME_ONLY);
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(caster_ptr, o_ptr, flgs);
bool is_pulish_successful = o_ptr->k_idx && !object_is_artifact(o_ptr) && !object_is_ego(o_ptr);
*/
static bool is_blessed_item(player_type *player_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
return has_flag(flgs, TR_BLESSED);
}
DICE_SID ds{}; /*!< ダイス値 / Damage when hits */
WEIGHT weight{}; /*!< 重量 / Weight */
PRICE cost{}; /*!< 基本価格 / Artifact "cost" */
- BIT_FLAGS flags[TR_FLAG_SIZE]{}; /*! アイテムフラグ / Artifact Flags */
+ TrFlags flags{}; /*! アイテムフラグ / Artifact Flags */
EnumClassFlagGroup<TRG> gen_flags; /*! アイテム生成フラグ / flags for generate */
DEPTH level{}; /*! 基本生成階 / Artifact level */
RARITY rarity{}; /*! レアリティ / Artifact rarity */
#define MAX_NLEN 160 /*!< Maximum length of object's name */
#define MAX_MONSTER_NAME 160 /*!< モンスター名称の最大バイト数 / Max characters of monster's name */
+constexpr ssize_t TR_FLAG_SIZE = 5;
+
/*!
* @brief 符号なし整数の簡潔な定義
*/
typedef int16_t FEAT_PRIORITY; /*!< 地形の縮小表示優先順位 */
+using TrFlags = BIT_FLAGS[TR_FLAG_SIZE];
+
enum process_result {
PROCESS_FALSE = 0,
PROCESS_TRUE = 1,
uint16_t art_name{}; /*!< Artifact name (random artifacts) */
byte feeling{}; /*!< Game generated inscription number (eg, pseudo-id) */
- BIT_FLAGS art_flags[TR_FLAG_SIZE]{}; /*!< Extra Flags for ego and artifacts */
+ TrFlags art_flags{}; /*!< Extra Flags for ego and artifacts */
EnumClassFlagGroup<TRC> curse_flags{}; /*!< Flags for curse */
MONSTER_IDX held_m_idx{}; /*!< アイテムを所持しているモンスターID (いないなら 0) / Monster holding us (if any) */
int artifact_bias{}; /*!< ランダムアーティファクト生成時のバイアスID */
#define MAX_NAZGUL_NUM 5
#define SCREEN_BUF_MAX_SIZE (1024 * 1024) /*!< Max size of screen dump buffer */
#define PY_MAX_LEVEL 50 /*!< プレイヤーレベルの最大値 / Maximum level */
-#define TR_FLAG_SIZE 5
#define PY_MAX_EXP 99999999L /*!< プレイヤー経験値の最大値 / Maximum exp */
#define MAX_SPELLS 108
#include <unordered_map>
struct all_player_flags {
- BIT_FLAGS player_flags[TR_FLAG_SIZE]{};
- BIT_FLAGS tim_player_flags[TR_FLAG_SIZE]{};
- BIT_FLAGS player_imm[TR_FLAG_SIZE]{};
- BIT_FLAGS tim_player_imm[TR_FLAG_SIZE]{};
- BIT_FLAGS player_vuln[TR_FLAG_SIZE]{};
- BIT_FLAGS known_obj_imm[TR_FLAG_SIZE]{};
- BIT_FLAGS riding_flags[TR_FLAG_SIZE]{};
- BIT_FLAGS riding_negative_flags[TR_FLAG_SIZE]{};
+ TrFlags player_flags{};
+ TrFlags tim_player_flags{};
+ TrFlags player_imm{};
+ TrFlags tim_player_imm{};
+ TrFlags player_vuln{};
+ TrFlags known_obj_imm{};
+ TrFlags riding_flags{};
+ TrFlags riding_negative_flags{};
};
/*!
{
int max_i = (mode & DP_WP) ? INVEN_BOW + 1 : INVEN_TOTAL;
for (int i = INVEN_MAIN_HAND; i < max_i; i++) {
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
auto *o_ptr = &creature_ptr->inventory_list[i];
auto is_known = object_is_known(o_ptr);
auto is_sensed = is_known || o_ptr->ident & IDENT_SENSE;
{
int max_i = (mode & DP_WP) ? INVEN_BOW + 1 : INVEN_TOTAL;
for (int i = INVEN_MAIN_HAND; i < max_i; i++) {
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
auto *o_ptr = &creature_ptr->inventory_list[i];
object_flags_known(creature_ptr, o_ptr, flags);
{
int max_i = (mode & DP_WP) ? INVEN_BOW + 1 : INVEN_TOTAL;
for (int i = INVEN_MAIN_HAND; i < max_i; i++) {
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
auto *o_ptr = &creature_ptr->inventory_list[i];
object_flags_known(creature_ptr, o_ptr, flags);
* @param stat 能力値番号
* @param flags 装備品に立っているフラグ
*/
-static void compensate_stat_by_weapon(char *c, TERM_COLOR *a, object_type *o_ptr, int stat, BIT_FLAGS *flags)
+static void compensate_stat_by_weapon(char *c, TERM_COLOR *a, object_type *o_ptr, int stat, const TrFlags &flags)
{
*c = '*';
* @param row 行数
* @param col 列数
*/
-static void display_equipments_compensation(player_type *creature_ptr, BIT_FLAGS *flags, int row, int *col)
+static void display_equipments_compensation(player_type *creature_ptr, TrFlags &flags, int row, int *col)
{
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
object_type *o_ptr;
* @param col 列数
* @param row 行数
*/
-static void display_mutation_compensation(player_type *creature_ptr, BIT_FLAGS *flags, int row, int col)
+static void display_mutation_compensation(player_type *creature_ptr, const TrFlags &flags, int row, int col)
{
for (int stat = 0; stat < A_MAX; stat++) {
byte a = TERM_SLATE;
c_put_str(TERM_WHITE, "abcdefghijkl@", row, col);
c_put_str(TERM_L_GREEN, _("能力修正", "Modification"), row - 1, col);
- BIT_FLAGS flags[TR_FLAG_SIZE];
+ TrFlags flags;
display_equipments_compensation(creature_ptr, flags, row, &col);
player_flags(creature_ptr, flags);
display_mutation_compensation(creature_ptr, flags, row, col);
* @param flgs オブジェクトフラグ群
* @return 強化後の素手ダメージ
*/
-static int strengthen_basedam(player_type *creature_ptr, object_type *o_ptr, int basedam, BIT_FLAGS *flgs)
+static int strengthen_basedam(player_type *creature_ptr, object_type *o_ptr, int basedam, const TrFlags &flgs)
{
if (object_is_fully_known(o_ptr) && ((o_ptr->name1 == ART_VORPAL_BLADE) || (o_ptr->name1 == ART_CHAINSWORD))) {
/* vorpal blade */
{
object_type *o_ptr;
o_ptr = &creature_ptr->inventory_list[INVEN_BOW];
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
for (int i = 0; i < 2; i++) {
int basedam;
damage[i] = creature_ptr->dis_to_d[i] * 100;
* The possibly updated description pointer is returned.
* </pre>
*/
-static concptr *spoiler_flag_aux(const BIT_FLAGS art_flags[TR_FLAG_SIZE], const flag_desc *flag_ptr, concptr *desc_ptr, const int n_elmnts)
+static concptr *spoiler_flag_aux(const TrFlags &art_flags, const flag_desc *flag_ptr, concptr *desc_ptr, const int n_elmnts)
{
for (int i = 0; i < n_elmnts; ++i)
if (has_flag(art_flags, flag_ptr[i].flag))
*/
static void analyze_pval(player_type *player_ptr, object_type *o_ptr, pval_info_type *pi_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
concptr *affects_list;
if (!o_ptr->pval) {
pi_ptr->pval_desc[0] = '\0';
*/
static void analyze_slay(player_type *player_ptr, object_type *o_ptr, concptr *slay_list)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
slay_list = spoiler_flag_aux(flgs, slay_flags_desc, slay_list, N_ELEMENTS(slay_flags_desc));
*slay_list = NULL;
*/
static void analyze_brand(player_type *player_ptr, object_type *o_ptr, concptr *brand_list)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
brand_list = spoiler_flag_aux(flgs, brand_flags_desc, brand_list, N_ELEMENTS(brand_flags_desc));
*brand_list = NULL;
*/
static void analyze_resist(player_type *player_ptr, object_type *o_ptr, concptr *resist_list)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
resist_list = spoiler_flag_aux(flgs, resist_flags_desc, resist_list, N_ELEMENTS(resist_flags_desc));
*resist_list = NULL;
*/
static void analyze_immune(player_type *player_ptr, object_type *o_ptr, concptr *immune_list)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
immune_list = spoiler_flag_aux(flgs, immune_flags_desc, immune_list, N_ELEMENTS(immune_flags_desc));
*immune_list = NULL;
*/
static void analyze_sustains(player_type *player_ptr, object_type *o_ptr, concptr *sustain_list)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
if (has_flag(flgs, TR_SUST_STR) && has_flag(flgs, TR_SUST_INT) && has_flag(flgs, TR_SUST_WIS) && has_flag(flgs, TR_SUST_DEX)
&& has_flag(flgs, TR_SUST_CON) && has_flag(flgs, TR_SUST_CHR)) {
*/
static void analyze_misc_magic(player_type *player_ptr, object_type *o_ptr, concptr *misc_list)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
char desc[256];
object_flags(player_ptr, o_ptr, flgs);
*/
static void wiz_display_item(player_type *player_ptr, object_type *o_ptr)
{
- BIT_FLAGS flgs[TR_FLAG_SIZE];
+ TrFlags flgs;
object_flags(player_ptr, o_ptr, flgs);
int j = 13;
for (int i = 1; i <= 23; i++)