-#include "player/player-status.h"
+#include "player/player-status.h"
#include "artifact/fixed-art-types.h"
#include "autopick/autopick-reader-writer.h"
#include "autopick/autopick.h"
#include "cmd-item/cmd-magiceat.h"
#include "combat/attack-power-table.h"
#include "core/asking-player.h"
-#include "core/player-redraw-types.h"
#include "core/stuff-handler.h"
#include "core/window-redrawer.h"
#include "dungeon/dungeon-flag-types.h"
#include "object-enchant/tr-types.h"
#include "object-enchant/trc-types.h"
#include "object-hook/hook-armor.h"
-#include "object/object-flags.h"
#include "object/object-info.h"
#include "object/object-mark-types.h"
#include "perception/object-perception.h"
#include "timed-effect/timed-effects.h"
#include "util/bit-flags-calculator.h"
#include "util/enum-converter.h"
-#include "util/quarks.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
#include "world/world.h"
for (int i = 0; i < floor_ptr->redraw_n; i++) {
POSITION y = floor_ptr->redraw_y[i];
POSITION x = floor_ptr->redraw_x[i];
- grid_type *g_ptr;
+ Grid *g_ptr;
g_ptr = &floor_ptr->grid_array[y][x];
if (none_bits(g_ptr->info, CAVE_REDRAW)) {
continue;
player_ptr->anti_magic = has_anti_magic(player_ptr);
player_ptr->anti_tele = has_anti_tele(player_ptr);
player_ptr->easy_spell = has_easy_spell(player_ptr);
- player_ptr->heavy_spell = has_heavy_spell(player_ptr);
+ player_ptr->hard_spell = has_hard_spell(player_ptr);
player_ptr->hold_exp = has_hold_exp(player_ptr);
player_ptr->see_inv = has_see_inv(player_ptr);
player_ptr->free_act = has_free_act(player_ptr);
player_ptr->dis_ac = calc_base_ac(player_ptr);
player_ptr->dis_to_a = calc_to_ac(player_ptr, false);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (old_mighty_throw != player_ptr->mighty_throw) {
- player_ptr->window_flags |= PW_INVENTORY;
+ rfu.set_flag(SubWindowRedrawingFlag::INVENTORY);
}
if (player_ptr->telepathy != old_telepathy) {
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ RedrawingFlagsUpdater::get_instance().set_flag(StatusRecalculatingFlag::MONSTER_STATUSES);
}
auto is_esp_updated = player_ptr->esp_animal != old_esp_animal;
is_esp_updated |= player_ptr->esp_good != old_esp_good;
is_esp_updated |= player_ptr->esp_nonliving != old_esp_nonliving;
is_esp_updated |= player_ptr->esp_unique != old_esp_unique;
- auto &rfu = RedrawingFlagsUpdater::get_instance();
if (is_esp_updated) {
- rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ rfu.set_flag(StatusRecalculatingFlag::MONSTER_STATUSES);
}
if (player_ptr->see_inv != old_see_inv) {
- rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ rfu.set_flag(StatusRecalculatingFlag::MONSTER_STATUSES);
}
if (player_ptr->pspeed != old_speed) {
if ((player_ptr->dis_ac != old_dis_ac) || (player_ptr->dis_to_a != old_dis_to_a)) {
rfu.set_flag(MainWindowRedrawingFlag::AC);
- set_bits(player_ptr->window_flags, PW_PLAYER);
+ rfu.set_flag(SubWindowRedrawingFlag::PLAYER);
}
if (w_ptr->character_xtra) {
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(MainWindowRedrawingFlag::HP);
- player_ptr->window_flags |= PW_PLAYER;
+ rfu.set_flag(SubWindowRedrawingFlag::PLAYER);
}
/*!
return;
}
- concptr p = spell_category_name(mp_ptr->spell_book);
+ const auto spell_category = spell_category_name(mp_ptr->spell_book);
int levels = player_ptr->lev - mp_ptr->spell_first + 1;
if (levels < 0) {
levels = 0;
const auto spell_name = exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME);
#ifdef JP
- msg_format("%sの%sを忘れてしまった。", spell_name->data(), p);
+ msg_format("%sの%sを忘れてしまった。", spell_name->data(), spell_category.data());
#else
- msg_format("You have forgotten the %s of %s.", p, spell_name->data());
+ msg_format("You have forgotten the %s of %s.", spell_category.data(), spell_name->data());
#endif
player_ptr->new_spells++;
}
const auto spell_name = exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME);
#ifdef JP
- msg_format("%sの%sを忘れてしまった。", spell_name->data(), p);
+ msg_format("%sの%sを忘れてしまった。", spell_name->data(), spell_category.data());
#else
- msg_format("You have forgotten the %s of %s.", p, spell_name->data());
+ msg_format("You have forgotten the %s of %s.", spell_category.data(), spell_name->data());
#endif
player_ptr->new_spells++;
}
const auto spell_name = exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME);
#ifdef JP
- msg_format("%sの%sを思い出した。", spell_name->data(), p);
+ msg_format("%sの%sを思い出した。", spell_name->data(), spell_category.data());
#else
- msg_format("You have remembered the %s of %s.", p, spell_name->data());
+ msg_format("You have remembered the %s of %s.", spell_category.data(), spell_name->data());
#endif
player_ptr->new_spells--;
}
if (player_ptr->new_spells) {
#ifdef JP
if (player_ptr->new_spells < 10) {
- msg_format("あと %d つの%sを学べる。", player_ptr->new_spells, p);
+ msg_format("あと %d つの%sを学べる。", player_ptr->new_spells, spell_category.data());
} else {
- msg_format("あと %d 個の%sを学べる。", player_ptr->new_spells, p);
+ msg_format("あと %d 個の%sを学べる。", player_ptr->new_spells, spell_category.data());
}
#else
- msg_format("You can learn %d more %s%s.", player_ptr->new_spells, p, (player_ptr->new_spells != 1) ? "s" : "");
+ msg_format("You can learn %d more %s%s.", player_ptr->new_spells, spell_category.data(), (player_ptr->new_spells != 1) ? "s" : "");
#endif
}
player_ptr->old_spells = player_ptr->new_spells;
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(MainWindowRedrawingFlag::STUDY);
- set_bits(player_ptr->window_flags, PW_ITEM_KNOWLEDGTE);
+ rfu.set_flag(SubWindowRedrawingFlag::ITEM_KNOWLEDGE);
}
/*!
if (any_bits(mp_ptr->spell_xtra, extra_magic_glove_reduce_mana)) {
player_ptr->cumber_glove = false;
- auto *o_ptr = &player_ptr->inventory_list[INVEN_ARMS];
- auto flags = object_flags(o_ptr);
+ const auto *o_ptr = &player_ptr->inventory_list[INVEN_ARMS];
+ const auto flags = o_ptr->get_flags();
auto should_mp_decrease = o_ptr->is_valid();
should_mp_decrease &= flags.has_not(TR_FREE_ACT);
should_mp_decrease &= flags.has_not(TR_DEC_MANA);
player_ptr->msp = msp;
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(MainWindowRedrawingFlag::MP);
- set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
+ static constexpr auto flags = {
+ SubWindowRedrawingFlag::PLAYER,
+ SubWindowRedrawingFlag::SPELL,
+ };
+ rfu.set_flags(flags);
}
if (w_ptr->character_xtra) {
continue;
}
- auto flags = object_flags(q_ptr);
- if (flags.has(TR_XTRA_SHOTS)) {
+ if (q_ptr->get_flags().has(TR_XTRA_SHOTS)) {
extra_shots++;
}
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_XTRA_SHOTS)) {
+ if (o_ptr->get_flags().has(TR_XTRA_SHOTS)) {
extra_shots++;
}
if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_MAGIC_MASTERY)) {
+
+ if (o_ptr->get_flags().has(TR_MAGIC_MASTERY)) {
pow += 8 * o_ptr->pval;
}
}
if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_SEARCH)) {
+
+ if (o_ptr->get_flags().has(TR_SEARCH)) {
pow += (o_ptr->pval * 5);
}
}
if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_SEARCH)) {
+
+ if (o_ptr->get_flags().has(TR_SEARCH)) {
pow += (o_ptr->pval * 5);
}
}
if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_TUNNEL)) {
+
+ if (o_ptr->get_flags().has(TR_TUNNEL)) {
pow += (o_ptr->pval * 20);
}
}
static int16_t calc_num_blow(PlayerType *player_ptr, int i)
{
- ItemEntity *o_ptr;
int16_t num_blow = 1;
- o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
- auto flags = object_flags(o_ptr);
+ const auto *o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
PlayerClass pc(player_ptr);
if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i)) {
if (o_ptr->is_valid() && !player_ptr->heavy_wield[i]) {
wgt = info.wgt;
mul = info.mul;
- if (pc.equals(PlayerClassType::CAVALRY) && player_ptr->riding && flags.has(TR_RIDING)) {
+ if (pc.equals(PlayerClassType::CAVALRY) && player_ptr->riding && o_ptr->get_flags().has(TR_RIDING)) {
num = 5;
wgt = 70;
mul = 4;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ItemEntity *o_ptr;
- o_ptr = &player_ptr->inventory_list[i];
- auto flags = object_flags(o_ptr);
+ const auto *o_ptr = &player_ptr->inventory_list[i];
+ const auto flags = o_ptr->get_flags();
if (!o_ptr->is_valid()) {
continue;
}
ac += o_ptr->to_a;
}
- if (o_ptr->curse_flags.has(CurseTraitType::LOW_AC) || object_flags(o_ptr).has(TR_LOW_AC)) {
+ if (o_ptr->curse_flags.has(CurseTraitType::LOW_AC) || flags.has(TR_LOW_AC)) {
if (o_ptr->curse_flags.has(CurseTraitType::HEAVY_CURSE)) {
if (is_real_value || o_ptr->is_fully_known()) {
ac -= 30;
int penalty = 0;
if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
- auto flags = object_flags(&player_ptr->inventory_list[INVEN_SUB_HAND]);
+ const auto flags = player_ptr->inventory_list[INVEN_SUB_HAND].get_flags();
penalty = ((100 - player_ptr->skill_exp[PlayerSkillKindType::TWO_WEAPON] / 160) - (130 - player_ptr->inventory_list[slot].weight) / 8);
if (set_quick_and_tiny(player_ptr) || set_icing_and_twinkle(player_ptr) || set_anubis_and_chariot(player_ptr)) {
if (has_two_handed_weapons(player_ptr) || (empty_hands(player_ptr, false) == EMPTY_HAND_NONE)) {
return true;
- } else if (any_bits(player_ptr->pet_extra_flags, PF_TWO_HANDS)) {
+ }
+
+ if (any_bits(player_ptr->pet_extra_flags, PF_TWO_HANDS)) {
switch (player_ptr->pclass) {
case PlayerClassType::MONK:
case PlayerClassType::FORCETRAINER:
case PlayerClassType::BERSERKER:
- 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)) {
- return true;
- }
-
+ return (empty_hands(player_ptr, false) != EMPTY_HAND_NONE) && !has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && !has_melee_weapon(player_ptr, INVEN_SUB_HAND);
default:
break;
}
static short calc_to_damage(PlayerType *player_ptr, INVENTORY_IDX slot, bool is_real_value)
{
- auto *o_ptr = &player_ptr->inventory_list[slot];
- auto flags = object_flags(o_ptr);
-
+ const auto *o_ptr = &player_ptr->inventory_list[slot];
player_hand calc_hand = PLAYER_HAND_OTHER;
if (slot == INVEN_MAIN_HAND) {
calc_hand = PLAYER_HAND_MAIN;
damage -= player_stun->get_damage_penalty();
PlayerClass pc(player_ptr);
const auto tval = o_ptr->bi_key.tval();
- if (pc.equals(PlayerClassType::PRIEST) && (flags.has_not(TR_BLESSED)) && ((tval == ItemKindType::SWORD) || (tval == ItemKindType::POLEARM))) {
+ if (pc.equals(PlayerClassType::PRIEST) && (o_ptr->get_flags().has_not(TR_BLESSED)) && ((tval == ItemKindType::SWORD) || (tval == ItemKindType::POLEARM))) {
damage -= 2;
} else if (pc.equals(PlayerClassType::BERSERKER)) {
damage += player_ptr->lev / 6;
/* Bonuses and penalties by weapon */
PlayerClass pc(player_ptr);
if (has_melee_weapon(player_ptr, slot)) {
- auto *o_ptr = &player_ptr->inventory_list[slot];
- auto flags = object_flags(o_ptr);
+ const auto *o_ptr = &player_ptr->inventory_list[slot];
/* Traind bonuses */
const auto tval = o_ptr->bi_key.tval();
- const auto sval = o_ptr->bi_key.sval().value();
+ const auto sval = *o_ptr->bi_key.sval();
hit += (player_ptr->weapon_exp[tval][sval] - PlayerSkill::weapon_exp_at(PlayerSkillRank::BEGINNER)) / 200;
/* Weight penalty */
}
/* Riding bonus and penalty */
+ const auto flags = o_ptr->get_flags();
if (player_ptr->riding > 0) {
if (o_ptr->is_lance()) {
hit += 15;
}
auto *floor_ptr = player_ptr->current_floor_ptr;
- if (rfu.has(StatusRedrawingFlag::AUTO_DESTRUCTION)) {
- rfu.reset_flag(StatusRedrawingFlag::AUTO_DESTRUCTION);
+ if (rfu.has(StatusRecalculatingFlag::AUTO_DESTRUCTION)) {
+ rfu.reset_flag(StatusRecalculatingFlag::AUTO_DESTRUCTION);
autopick_delayed_alter(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::COMBINATION)) {
- rfu.reset_flag(StatusRedrawingFlag::COMBINATION);
+ if (rfu.has(StatusRecalculatingFlag::COMBINATION)) {
+ rfu.reset_flag(StatusRecalculatingFlag::COMBINATION);
combine_pack(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::REORDER)) {
- rfu.reset_flag(StatusRedrawingFlag::REORDER);
+ if (rfu.has(StatusRecalculatingFlag::REORDER)) {
+ rfu.reset_flag(StatusRecalculatingFlag::REORDER);
reorder_pack(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::BONUS)) {
- rfu.reset_flag(StatusRedrawingFlag::BONUS);
+ if (rfu.has(StatusRecalculatingFlag::BONUS)) {
+ rfu.reset_flag(StatusRecalculatingFlag::BONUS);
PlayerAlignment(player_ptr).update_alignment();
PlayerSkill ps(player_ptr);
ps.apply_special_weapon_skill_max_values();
update_bonuses(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::TORCH)) {
- rfu.reset_flag(StatusRedrawingFlag::TORCH);
+ if (rfu.has(StatusRecalculatingFlag::TORCH)) {
+ rfu.reset_flag(StatusRecalculatingFlag::TORCH);
update_lite_radius(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::HP)) {
- rfu.reset_flag(StatusRedrawingFlag::HP);
+ if (rfu.has(StatusRecalculatingFlag::HP)) {
+ rfu.reset_flag(StatusRecalculatingFlag::HP);
update_max_hitpoints(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::MP)) {
- rfu.reset_flag(StatusRedrawingFlag::MP);
+ if (rfu.has(StatusRecalculatingFlag::MP)) {
+ rfu.reset_flag(StatusRecalculatingFlag::MP);
update_max_mana(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::SPELLS)) {
- rfu.reset_flag(StatusRedrawingFlag::SPELLS);
+ if (rfu.has(StatusRecalculatingFlag::SPELLS)) {
+ rfu.reset_flag(StatusRecalculatingFlag::SPELLS);
update_num_of_spells(player_ptr);
}
return;
}
- if (rfu.has(StatusRedrawingFlag::UN_LITE)) {
- rfu.reset_flag(StatusRedrawingFlag::UN_LITE);
+ if (rfu.has(StatusRecalculatingFlag::UN_LITE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::UN_LITE);
forget_lite(floor_ptr);
}
- if (rfu.has(StatusRedrawingFlag::UN_VIEW)) {
- rfu.reset_flag(StatusRedrawingFlag::UN_VIEW);
+ if (rfu.has(StatusRecalculatingFlag::UN_VIEW)) {
+ rfu.reset_flag(StatusRecalculatingFlag::UN_VIEW);
forget_view(floor_ptr);
}
- if (rfu.has(StatusRedrawingFlag::VIEW)) {
- rfu.reset_flag(StatusRedrawingFlag::VIEW);
+ if (rfu.has(StatusRecalculatingFlag::VIEW)) {
+ rfu.reset_flag(StatusRecalculatingFlag::VIEW);
update_view(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::LITE)) {
- rfu.reset_flag(StatusRedrawingFlag::LITE);
+ if (rfu.has(StatusRecalculatingFlag::LITE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::LITE);
update_lite(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::FLOW)) {
- rfu.reset_flag(StatusRedrawingFlag::FLOW);
+ if (rfu.has(StatusRecalculatingFlag::FLOW)) {
+ rfu.reset_flag(StatusRecalculatingFlag::FLOW);
update_flow(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::DISTANCE)) {
- rfu.reset_flag(StatusRedrawingFlag::DISTANCE);
+ if (rfu.has(StatusRecalculatingFlag::DISTANCE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::DISTANCE);
update_monsters(player_ptr, true);
}
- if (rfu.has(StatusRedrawingFlag::MONSTER_LITE)) {
- rfu.reset_flag(StatusRedrawingFlag::MONSTER_LITE);
+ if (rfu.has(StatusRecalculatingFlag::MONSTER_LITE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::MONSTER_LITE);
update_mon_lite(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::DELAY_VISIBILITY)) {
- rfu.reset_flag(StatusRedrawingFlag::DELAY_VISIBILITY);
+ if (rfu.has(StatusRecalculatingFlag::DELAY_VISIBILITY)) {
+ rfu.reset_flag(StatusRecalculatingFlag::DELAY_VISIBILITY);
delayed_visual_update(player_ptr);
}
- if (rfu.has(StatusRedrawingFlag::MONSTER_STATUSES)) {
- rfu.reset_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ if (rfu.has(StatusRecalculatingFlag::MONSTER_STATUSES)) {
+ rfu.reset_flag(StatusRecalculatingFlag::MONSTER_STATUSES);
update_monsters(player_ptr, false);
}
}
void wreck_the_pattern(PlayerType *player_ptr)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
- int pattern_type = terrains_info[floor_ptr->grid_array[player_ptr->y][player_ptr->x].feat].subtype;
- if (pattern_type == PATTERN_TILE_WRECKED) {
+ const auto p_pos = player_ptr->get_position();
+ const auto &terrain = floor_ptr->get_grid(p_pos).get_terrain();
+ if (terrain.subtype == PATTERN_TILE_WRECKED) {
return;
}
take_hit(player_ptr, DAMAGE_NOESCAPE, damroll(10, 8), _("パターン損壊", "corrupting the Pattern"));
}
- int to_ruin = randint1(45) + 35;
+ auto to_ruin = randint1(45) + 35;
while (to_ruin--) {
- POSITION r_y, r_x;
- scatter(player_ptr, &r_y, &r_x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);
-
- if (pattern_tile(floor_ptr, r_y, r_x) && (terrains_info[floor_ptr->grid_array[r_y][r_x].feat].subtype != PATTERN_TILE_WRECKED)) {
- cave_set_feat(player_ptr, r_y, r_x, feat_pattern_corrupted);
+ int y;
+ int x;
+ scatter(player_ptr, &y, &x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);
+ const Pos2D pos(y, x);
+ if (pattern_tile(floor_ptr, pos.y, pos.x) && (floor_ptr->get_grid(pos).get_terrain().subtype != PATTERN_TILE_WRECKED)) {
+ cave_set_feat(player_ptr, pos.y, pos.x, feat_pattern_corrupted);
}
}
PlayerRace pr(player_ptr);
bool android = pr.equals(PlayerRaceType::ANDROID);
PLAYER_LEVEL old_lev = player_ptr->lev;
- const auto flags_srf = {
- StatusRedrawingFlag::BONUS,
- StatusRedrawingFlag::HP,
- StatusRedrawingFlag::MP,
- StatusRedrawingFlag::SPELLS,
+ static constexpr auto flags_srf = {
+ StatusRecalculatingFlag::BONUS,
+ StatusRecalculatingFlag::HP,
+ StatusRecalculatingFlag::MP,
+ StatusRecalculatingFlag::SPELLS,
};
while ((player_ptr->lev > 1) && (player_ptr->exp < ((android ? player_exp_a : player_exp)[player_ptr->lev - 2] * player_ptr->expfact / 100L))) {
player_ptr->lev--;
rfu.set_flags(flags_srf);
- const auto flags_mwrf = {
+ static constexpr auto flags_mwrf = {
MainWindowRedrawingFlag::LEVEL,
MainWindowRedrawingFlag::TITLE,
};
rfu.set_flags(flags_mwrf);
- set_bits(player_ptr->window_flags, PW_PLAYER);
+ rfu.set_flag(SubWindowRedrawingFlag::PLAYER);
handle_stuff(player_ptr);
}
}
level_inc_stat = true;
- exe_write_diary(player_ptr, DIARY_LEVELUP, player_ptr->lev, nullptr);
+ exe_write_diary(player_ptr, DiaryKind::LEVELUP, player_ptr->lev);
}
sound(SOUND_LEVEL);
MainWindowRedrawingFlag::EXP,
};
rfu.set_flags(flags_mwrf_levelup);
- set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL | PW_INVENTORY));
+ const auto &flags_swrf_levelup = {
+ SubWindowRedrawingFlag::PLAYER,
+ SubWindowRedrawingFlag::SPELL,
+ SubWindowRedrawingFlag::INVENTORY,
+ };
+ rfu.set_flags(flags_swrf_levelup);
player_ptr->level_up_message = true;
handle_stuff(player_ptr);
prt("", n + 2, 14);
}
}
- if (get_check(_("よろしいですか？", "Are you sure? "))) {
+ if (input_check(_("よろしいですか？", "Are you sure? "))) {
break;
}
}
}
rfu.set_flags(flags_srf);
- const auto flags_mwrf = {
+ static constexpr auto flags_mwrf = {
MainWindowRedrawingFlag::LEVEL,
MainWindowRedrawingFlag::TITLE,
};
rfu.set_flags(flags_mwrf);
- set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
+ static constexpr auto flags_swrf = {
+ SubWindowRedrawingFlag::PLAYER,
+ SubWindowRedrawingFlag::SPELL,
+ };
+ rfu.set_flags(flags_swrf);
handle_stuff(player_ptr);
}
bool is_tim_esp(PlayerType *player_ptr)
{
- auto sniper_data = PlayerClass(player_ptr).get_specific_data<sniper_data_type>();
+ auto sniper_data = PlayerClass(player_ptr).get_specific_data<SniperData>();
auto sniper_concent = sniper_data ? sniper_data->concent : 0;
return player_ptr->tim_esp || music_singing(player_ptr, MUSIC_MIND) || (sniper_concent >= CONCENT_TELE_THRESHOLD);
}
bool is_time_limit_esp(PlayerType *player_ptr)
{
- auto sniper_data = PlayerClass(player_ptr).get_specific_data<sniper_data_type>();
+ auto sniper_data = PlayerClass(player_ptr).get_specific_data<SniperData>();
auto sniper_concent = sniper_data ? sniper_data->concent : 0;
return player_ptr->tim_esp || music_singing(player_ptr, MUSIC_MIND) || (sniper_concent >= CONCENT_TELE_THRESHOLD);
}
OSDN Git Service
