#include "spell/spells-status.h"
#include "sv-definition/sv-weapon-types.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include <array>
namespace {
}
player_ptr->knowledge &= ~(KNOW_STAT);
- player_ptr->redraw |= (PR_ABILITY_SCORE);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ABILITY_SCORE);
}
#include "status/experience.h"
#include "system/angband.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "timed-effect/player-blindness.h"
#include "timed-effect/player-confusion.h"
#include "timed-effect/player-hallucination.h"
gain_exp(player_ptr, monster_power.level * monster_power.smana);
sound(SOUND_STUDY);
bluemage_data->new_magic_learned = true;
- player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
}
}
}
PlayerEnergy(player_ptr).set_player_turn_energy(100);
-
- /* Use some mana */
player_ptr->csp -= spell.smana;
-
- /* Limit */
if (player_ptr->csp < 0) {
player_ptr->csp = 0;
}
- player_ptr->redraw |= (PR_MP);
+
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
player_ptr->window_flags |= (PW_PLAYER | PW_SPELL);
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "target/projection-path-calculator.h"
#include "target/target-checker.h"
#include "target/target-getter.h"
}
mane_data->mane_list.erase(std::next(mane_data->mane_list.begin(), n));
-
PlayerEnergy(player_ptr).set_player_turn_energy(100);
-
- player_ptr->redraw |= (PR_IMITATION);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::IMITATION);
player_ptr->window_flags |= (PW_PLAYER);
player_ptr->window_flags |= (PW_SPELL);
-
return true;
}
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/screen-processor.h"
#include "timed-effect/player-stun.h"
#include "timed-effect/timed-effects.h"
{
if ((cm_ptr->use_mind == MindKindType::BERSERKER) || (cm_ptr->use_mind == MindKindType::NINJUTSU)) {
take_hit(player_ptr, DAMAGE_USELIFE, cm_ptr->mana_cost, _("過度の集中", "concentrating too hard"));
- player_ptr->redraw |= PR_HP;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::HP);
return;
}
mind_turn_passing(player_ptr, cm_ptr);
process_hard_concentration(player_ptr, cm_ptr);
- player_ptr->redraw |= PR_MP;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
player_ptr->window_flags |= PW_PLAYER;
player_ptr->window_flags |= PW_SPELL;
}
{
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
uint32_t mpe_mode = MPE_STAYING | MPE_ENERGY_USE;
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= (PR_ACTION);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
player_ptr->action = ACTION_REST;
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- player_ptr->redraw |= (PR_ACTION);
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
handle_stuff(player_ptr);
term_fresh();
}
#include "system/grid-type-definition.h"
#include "system/item-entity.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "system/terrain-type-definition.h"
#include "target/target-getter.h"
#include "term/screen-processor.h"
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= (PR_ACTION);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= (PR_ACTION);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= (PR_ACTION);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "system/terrain-type-definition.h"
#include "target/target-getter.h"
#include "term/screen-processor.h"
{
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
player_ptr->riding = 0;
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= (PR_EXTRA | PR_UHEALTH);
+ const auto flags = {
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::UHEALTH,
+ };
+ rfu.set_flags(flags);
}
- /* HACK : Add the line to message buffer */
msg_format(_("%s を放した。", "Dismissed %s."), friend_name.data());
rfu.set_flag(StatusRedrawingFlag::BONUS);
player_ptr->window_flags |= (PW_MESSAGE);
StatusRedrawingFlag::BONUS,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_MAP | PR_EXTRA);
- player_ptr->redraw |= (PR_UHEALTH);
-
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::UHEALTH,
+ };
+ rfu.set_flags(flags_mwrf);
(void)move_player_effect(player_ptr, y, x, MPE_HANDLE_STUFF | MPE_ENERGY_USE | MPE_DONT_PICKUP | MPE_DONT_SWAP_MON);
-
return true;
}
#include "racial/racial-util.h"
#include "status/action-setter.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/screen-processor.h"
#include "term/z-form.h"
#include "util/bit-flags-calculator.h"
return;
}
- set_bits(player_ptr->redraw, PR_HP | PR_MP);
+ const auto flags = {
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
+ RedrawingFlagsUpdater::get_instance().set_flags(flags);
set_bits(player_ptr->window_flags, PW_PLAYER | PW_SPELL);
}
} else {
over_exerted = true;
}
- player_ptr->redraw |= (PR_MP);
+
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
/* Over-exert the player */
if (over_exerted) {
#include "system/floor-type-definition.h"
#include "system/grid-type-definition.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "system/terrain-type-definition.h"
#include "target/target-getter.h"
#include "util/bit-flags-calculator.h"
if (command_arg) {
command_rep = command_arg - 1;
- player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
command_arg = 0;
}
term_clear();
auto &rfu = RedrawingFlagsUpdater::get_instance();
- const auto flags = {
+ const auto flags_srf = {
StatusRedrawingFlag::VIEW,
StatusRedrawingFlag::MONSTER_STATUSES,
StatusRedrawingFlag::BONUS,
StatusRedrawingFlag::LITE,
StatusRedrawingFlag::MONSTER_LITE,
};
- rfu.set_flags(flags);
- player_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_EQUIPPY | PR_MAP);
+ rfu.set_flags(flags_srf);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::EQUIPPY,
+ MainWindowRedrawingFlag::MAP,
+ };
+ rfu.set_flags(flags_mwrf);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
}
verify_panel(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
handle_stuff(player_ptr);
}
#include "main/sound-of-music.h"
#include "system/game-option-types.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/gameterm.h"
#include "term/screen-processor.h"
#include "term/term-color-types.h"
}
screen_load();
- player_ptr->redraw |= (PR_EQUIPPY);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::EQUIPPY);
}
/*!
#include "io/files-util.h"
#include "io/input-key-acceptor.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/gameterm.h"
#include "term/screen-processor.h"
#include "term/term-color-types.h"
use_graphics = false;
reset_visuals(player_ptr);
- player_ptr->redraw |= (PR_WIPE | PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIPPY);
+ const auto flags = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::EQUIPPY,
+ };
+ RedrawingFlagsUpdater::get_instance().set_flags(flags);
handle_stuff(player_ptr);
return false;
}
use_graphics = true;
reset_visuals(player_ptr);
- player_ptr->redraw |= (PR_WIPE | PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIPPY);
+ const auto flags = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::EQUIPPY,
+ };
+ RedrawingFlagsUpdater::get_instance().set_flags(flags);
handle_stuff(player_ptr);
}
};
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flags(flags_srf);
- player_ptr->redraw |= PR_EQUIPPY;
+ rfu.set_flag(MainWindowRedrawingFlag::EQUIPPY);
player_ptr->window_flags |= PW_INVENTORY | PW_EQUIPMENT | PW_PLAYER;
}
StatusRedrawingFlag::MP,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= PR_EQUIPPY;
+ rfu.set_flag(MainWindowRedrawingFlag::EQUIPPY);
player_ptr->window_flags |= PW_INVENTORY | PW_EQUIPMENT | PW_PLAYER;
}
calc_android_exp(player_ptr);
}
- player_ptr->redraw |= (PR_EQUIPPY);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::EQUIPPY);
}
/*!
#include "status/action-setter.h"
#include "system/item-entity.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
ThrowCommand::ThrowCommand(PlayerType *player_ptr)
: player_ptr(player_ptr)
ote.reflect_inventory_by_throw();
if (ote.item >= INVEN_MAIN_HAND) {
ote.equiped_item = true;
- this->player_ptr->redraw |= PR_EQUIPPY;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::EQUIPPY);
}
ote.set_class_specific_throw_params();
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
-
- player_ptr->redraw |= (PR_WIPE | PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIPPY);
-
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::EQUIPPY,
+ MainWindowRedrawingFlag::MAP,
+ };
+ rfu.set_flags(flags_mwrf);
player_ptr->window_flags |= (PW_INVENTORY | PW_EQUIPMENT | PW_SPELL | PW_PLAYER);
player_ptr->window_flags |= (PW_MESSAGE | PW_OVERHEAD | PW_DUNGEON | PW_MONSTER_LORE | PW_ITEM_KNOWLEDGTE);
-
update_playtime();
handle_stuff(player_ptr);
if (PlayerRace(player_ptr).equals(PlayerRaceType::ANDROID)) {
}
screen_load();
- player_ptr->redraw |= (PR_WIPE | PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIPPY);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::EQUIPPY,
+ MainWindowRedrawingFlag::MAP,
+ };
+ rfu.set_flags(flags_mwrf);
handle_stuff(player_ptr);
}
if ((flags.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (player_ptr->msp / 30))) {
player_ptr->csp -= (1 + (player_ptr->msp / 30));
- set_bits(player_ptr->redraw, PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
mult = mult * 5 / 2;
}
break;
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
/*!
if (!pc.equals(PlayerClassType::SAMURAI) && (flags.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (o_ptr->dd * o_ptr->ds / 5))) {
player_ptr->csp -= (1 + (o_ptr->dd * o_ptr->ds / 5));
- player_ptr->redraw |= (PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
mult = mult * 3 / 2 + 20;
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
if (command_rep) {
command_rep = 0;
- player_ptr->redraw |= PR_ACTION;
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
}
if ((player_ptr->action == ACTION_REST) || (player_ptr->action == ACTION_FISH) || (stop_search && (player_ptr->action == ACTION_SEARCH))) {
#include "system/item-entity.h"
#include "system/monster-entity.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "view/display-messages.h"
#include <algorithm>
ItemEntity *o_ptr;
if (size) {
msg_print(_("アイテム情報を圧縮しています...", "Compacting objects..."));
- player_ptr->redraw |= PR_MAP;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
}
s64b_sub(&(player_ptr->csp), &(player_ptr->csp_frac), cost, cost_frac);
}
- player_ptr->redraw |= PR_MP;
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
}
if (PlayerClass(player_ptr).samurai_stance_is(SamuraiStanceType::MUSOU)) {
set_action(player_ptr, ACTION_NONE);
} else {
player_ptr->csp -= 2;
- player_ptr->redraw |= (PR_MP);
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
}
}
if (!player_ptr->resting) {
set_action(player_ptr, ACTION_NONE);
}
- player_ptr->redraw |= (PR_ACTION);
+
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
}
energy.set_player_turn_energy(100);
travel_step(player_ptr);
} else if (command_rep) {
command_rep--;
- player_ptr->redraw |= (PR_ACTION);
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
handle_stuff(player_ptr);
msg_flag = false;
prt("", 0, 0);
}
if (effects->hallucination()->is_hallucinated()) {
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
}
for (MONSTER_IDX m_idx = 1; m_idx < player_ptr->current_floor_ptr->m_max; m_idx++) {
m_ptr->ml = false;
update_monster(player_ptr, m_idx, false);
if (player_ptr->health_who == m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
+
if (player_ptr->riding == m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
lite_spot(player_ptr, m_ptr->fy, m_ptr->fx);
}
mane_data->new_mane = false;
- player_ptr->redraw |= (PR_IMITATION);
+ rfu.set_flag(MainWindowRedrawingFlag::IMITATION);
}
if (player_ptr->action == ACTION_LEARN) {
auto mane_data = PlayerClass(player_ptr).get_specific_data<bluemage_data_type>();
mane_data->new_magic_learned = false;
- player_ptr->redraw |= (PR_ACTION);
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
}
if (player_ptr->timewalk && (player_ptr->energy_need > -1000)) {
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
update_creature(player_ptr);
}
- if (player_ptr->redraw) {
+ if (rfu.any_main()) {
redraw_stuff(player_ptr);
}
}
player_ptr->health_who = m_idx;
- player_ptr->redraw |= (PR_HEALTH);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::HEALTH);
}
bool update_player(PlayerType *player_ptr)
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= PR_MP;
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
const auto flags_srf = {
StatusRedrawingFlag::COMBINATION,
StatusRedrawingFlag::REORDER,
#include "player-base/player-class.h"
#include "player-info/race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/gameterm.h"
#include "term/screen-processor.h"
#include "term/term-color-types.h"
*/
void redraw_stuff(PlayerType *player_ptr)
{
- if (!player_ptr->redraw) {
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ if (!rfu.any_main()) {
return;
}
return;
}
- if (player_ptr->redraw & (PR_WIPE)) {
- player_ptr->redraw &= ~(PR_WIPE);
+ if (rfu.has(MainWindowRedrawingFlag::WIPE)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::WIPE);
msg_print(nullptr);
term_clear();
}
- if (player_ptr->redraw & (PR_MAP)) {
- player_ptr->redraw &= ~(PR_MAP);
+ if (rfu.has(MainWindowRedrawingFlag::MAP)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::MAP);
print_map(player_ptr);
}
- if (player_ptr->redraw & (PR_BASIC)) {
- player_ptr->redraw &= ~(PR_BASIC);
- player_ptr->redraw &= ~(PR_MISC | PR_TITLE | PR_ABILITY_SCORE);
- player_ptr->redraw &= ~(PR_LEVEL | PR_EXP | PR_GOLD);
- player_ptr->redraw &= ~(PR_AC | PR_HP | PR_MP);
- player_ptr->redraw &= ~(PR_DEPTH | PR_HEALTH | PR_UHEALTH);
+ if (rfu.has(MainWindowRedrawingFlag::BASIC)) {
+ const auto flags = {
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::MISC,
+ MainWindowRedrawingFlag::TITLE,
+ MainWindowRedrawingFlag::ABILITY_SCORE,
+ MainWindowRedrawingFlag::LEVEL,
+ MainWindowRedrawingFlag::EXP,
+ MainWindowRedrawingFlag::GOLD,
+ MainWindowRedrawingFlag::AC,
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ MainWindowRedrawingFlag::DEPTH,
+ MainWindowRedrawingFlag::HEALTH,
+ MainWindowRedrawingFlag::UHEALTH,
+ };
+ rfu.reset_flags(flags);
print_frame_basic(player_ptr);
WorldTurnProcessor(player_ptr).print_time();
print_dungeon(player_ptr);
}
- if (player_ptr->redraw & (PR_EQUIPPY)) {
- player_ptr->redraw &= ~(PR_EQUIPPY);
+ if (rfu.has(MainWindowRedrawingFlag::EQUIPPY)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::EQUIPPY);
display_player_equippy(player_ptr, ROW_EQUIPPY, COL_EQUIPPY, 0);
}
- if (player_ptr->redraw & (PR_MISC)) {
- player_ptr->redraw &= ~(PR_MISC);
+ if (rfu.has(MainWindowRedrawingFlag::MISC)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::MISC);
print_field(rp_ptr->title, ROW_RACE, COL_RACE);
}
- if (player_ptr->redraw & (PR_TITLE)) {
- player_ptr->redraw &= ~(PR_TITLE);
+ if (rfu.has(MainWindowRedrawingFlag::TITLE)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::TITLE);
print_title(player_ptr);
}
- if (player_ptr->redraw & (PR_LEVEL)) {
- player_ptr->redraw &= ~(PR_LEVEL);
+ if (rfu.has(MainWindowRedrawingFlag::LEVEL)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::LEVEL);
print_level(player_ptr);
}
- if (player_ptr->redraw & (PR_EXP)) {
- player_ptr->redraw &= ~(PR_EXP);
+ if (rfu.has(MainWindowRedrawingFlag::EXP)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::EXP);
print_exp(player_ptr);
}
- if (player_ptr->redraw & (PR_ABILITY_SCORE)) {
- player_ptr->redraw &= ~(PR_ABILITY_SCORE);
+ if (rfu.has(MainWindowRedrawingFlag::ABILITY_SCORE)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::ABILITY_SCORE);
print_stat(player_ptr, A_STR);
print_stat(player_ptr, A_INT);
print_stat(player_ptr, A_WIS);
print_stat(player_ptr, A_CHR);
}
- if (player_ptr->redraw & (PR_TIMED_EFFECT)) {
- player_ptr->redraw &= ~(PR_TIMED_EFFECT);
+ if (rfu.has(MainWindowRedrawingFlag::TIMED_EFFECT)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
print_status(player_ptr);
}
- if (player_ptr->redraw & (PR_AC)) {
- player_ptr->redraw &= ~(PR_AC);
+ if (rfu.has(MainWindowRedrawingFlag::AC)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::AC);
print_ac(player_ptr);
}
- if (player_ptr->redraw & (PR_HP)) {
- player_ptr->redraw &= ~(PR_HP);
+ if (rfu.has(MainWindowRedrawingFlag::HP)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::HP);
print_hp(player_ptr);
}
- if (player_ptr->redraw & (PR_MP)) {
- player_ptr->redraw &= ~(PR_MP);
+ if (rfu.has(MainWindowRedrawingFlag::MP)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::MP);
print_sp(player_ptr);
}
- if (player_ptr->redraw & (PR_GOLD)) {
- player_ptr->redraw &= ~(PR_GOLD);
+ if (rfu.has(MainWindowRedrawingFlag::GOLD)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::GOLD);
print_gold(player_ptr);
}
- if (player_ptr->redraw & (PR_DEPTH)) {
- player_ptr->redraw &= ~(PR_DEPTH);
+ if (rfu.has(MainWindowRedrawingFlag::DEPTH)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::DEPTH);
print_depth(player_ptr);
}
- if (player_ptr->redraw & (PR_UHEALTH)) {
- player_ptr->redraw &= ~(PR_UHEALTH);
+ if (rfu.has(MainWindowRedrawingFlag::UHEALTH)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::UHEALTH);
print_health(player_ptr, true);
}
- if (player_ptr->redraw & (PR_HEALTH)) {
- player_ptr->redraw &= ~(PR_HEALTH);
+ if (rfu.has(MainWindowRedrawingFlag::HEALTH)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::HEALTH);
print_health(player_ptr, false);
}
- if (player_ptr->redraw & (PR_EXTRA)) {
- player_ptr->redraw &= ~(PR_EXTRA);
- player_ptr->redraw &= ~(PR_CUT | PR_STUN);
- player_ptr->redraw &= ~(PR_HUNGER);
- player_ptr->redraw &= ~(PR_ACTION | PR_SPEED | PR_STUDY | PR_IMITATION | PR_TIMED_EFFECT);
+ if (rfu.has(MainWindowRedrawingFlag::EXTRA)) {
+ const auto flags = {
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::CUT,
+ MainWindowRedrawingFlag::STUN,
+ MainWindowRedrawingFlag::HUNGER,
+ MainWindowRedrawingFlag::ACTION,
+ MainWindowRedrawingFlag::SPEED,
+ MainWindowRedrawingFlag::STUDY,
+ MainWindowRedrawingFlag::IMITATION,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ };
+ rfu.reset_flags(flags);
print_frame_extra(player_ptr);
}
- if (player_ptr->redraw & (PR_CUT)) {
- player_ptr->redraw &= ~(PR_CUT);
+ if (rfu.has(MainWindowRedrawingFlag::CUT)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::CUT);
print_cut(player_ptr);
}
- if (player_ptr->redraw & (PR_STUN)) {
- player_ptr->redraw &= ~(PR_STUN);
+ if (rfu.has(MainWindowRedrawingFlag::STUN)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::STUN);
print_stun(player_ptr);
}
- if (player_ptr->redraw & (PR_HUNGER)) {
- player_ptr->redraw &= ~(PR_HUNGER);
+ if (rfu.has(MainWindowRedrawingFlag::HUNGER)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::HUNGER);
print_hunger(player_ptr);
}
- if (player_ptr->redraw & (PR_ACTION)) {
- player_ptr->redraw &= ~(PR_ACTION);
+ if (rfu.has(MainWindowRedrawingFlag::ACTION)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::ACTION);
print_state(player_ptr);
}
- if (player_ptr->redraw & (PR_SPEED)) {
- player_ptr->redraw &= ~(PR_SPEED);
+ if (rfu.has(MainWindowRedrawingFlag::SPEED)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::SPEED);
print_speed(player_ptr);
}
if (PlayerClass(player_ptr).equals(PlayerClassType::IMITATOR)) {
- if (player_ptr->redraw & (PR_IMITATION)) {
- player_ptr->redraw &= ~(PR_IMITATION);
+ if (rfu.has(MainWindowRedrawingFlag::IMITATION)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::IMITATION);
print_imitation(player_ptr);
}
return;
}
- if (player_ptr->redraw & (PR_STUDY)) {
- player_ptr->redraw &= ~(PR_STUDY);
+ if (rfu.has(MainWindowRedrawingFlag::STUDY)) {
+ rfu.reset_flag(MainWindowRedrawingFlag::STUDY);
print_study(player_ptr);
}
}
{
w_ptr->character_xtra = true;
auto &rfu = RedrawingFlagsUpdater::get_instance();
+ set_bits(player_ptr->window_flags, PW_INVENTORY | PW_EQUIPMENT | PW_SPELL | PW_PLAYER | PW_MONSTER_LORE | PW_OVERHEAD | PW_DUNGEON);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::EQUIPPY,
+ MainWindowRedrawingFlag::MAP,
+ };
+ rfu.set_flags(flags_mwrf);
auto flags_srf = {
StatusRedrawingFlag::BONUS,
StatusRedrawingFlag::HP,
StatusRedrawingFlag::DISTANCE,
StatusRedrawingFlag::FLOW,
};
- set_bits(player_ptr->window_flags, PW_INVENTORY | PW_EQUIPMENT | PW_SPELL | PW_PLAYER | PW_MONSTER_LORE | PW_OVERHEAD | PW_DUNGEON);
- set_bits(player_ptr->redraw, PR_WIPE | PR_BASIC | PR_EXTRA | PR_EQUIPPY | PR_MAP);
rfu.set_flags(flags_srf);
handle_stuff(player_ptr);
w_ptr->character_xtra = false;
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "view/display-messages.h"
em_ptr->m_ptr->maxhp = em_ptr->m_ptr->max_maxhp;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (!em_ptr->dam) {
if (player_ptr->health_who == em_ptr->g_ptr->m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
+
if (player_ptr->riding == em_ptr->g_ptr->m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
return ProcessResult::PROCESS_FALSE;
}
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == em_ptr->g_ptr->m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
+
if (player_ptr->riding == em_ptr->g_ptr->m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
em_ptr->note = _("は体力を回復したようだ。", " looks healthier.");
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
player_ptr->csp = 0;
}
- set_bits(player_ptr->redraw, PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
set_bits(player_ptr->window_flags, PW_SPELL);
take_hit(player_ptr, DAMAGE_ATTACK, em_ptr->dam, em_ptr->killer);
em_ptr->dam = 0;
b = std::min(player_ptr->msp, player_ptr->csp + b);
player_ptr->csp = b;
- set_bits(player_ptr->redraw, PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
set_bits(player_ptr->window_flags, PW_SPELL);
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
em_ptr->m_caster_ptr->hp = em_ptr->m_caster_ptr->maxhp;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == em_ptr->who) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == em_ptr->who) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
if (em_ptr->see_s_msg) {
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
return false;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == em_ptr->g_ptr->m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
+
if (player_ptr->riding == em_ptr->g_ptr->m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
(void)set_monster_csleep(player_ptr, em_ptr->g_ptr->m_idx, 0);
}
player_ptr->health_who = em_ptr->g_ptr->m_idx;
- player_ptr->redraw |= (PR_HEALTH);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::HEALTH);
handle_stuff(player_ptr);
}
msg_print(_("閃光のため非物質的な影の存在でいられなくなった。", "The light forces you out of your incorporeal shadow form."));
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_MAP | PR_TIMED_EFFECT);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ };
+ rfu.set_flags(flags_mwrf);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
}
#include "status/base-status.h"
#include "system/monster-entity.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "view/display-messages.h"
#include "world/world.h"
player_ptr->csp -= ep_ptr->dam;
}
- player_ptr->redraw |= (PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
player_ptr->window_flags |= (PW_PLAYER | PW_SPELL);
if ((ep_ptr->who <= 0) || (ep_ptr->m_ptr->hp >= ep_ptr->m_ptr->maxhp)) {
}
if (player_ptr->health_who == ep_ptr->who) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == ep_ptr->who) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
if (ep_ptr->m_ptr->ml) {
player_ptr->csp_frac = 0;
}
- player_ptr->redraw |= PR_MP;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
ep_ptr->get_damage = take_hit(player_ptr, DAMAGE_ATTACK, ep_ptr->dam, ep_ptr->killer);
}
if (!check_multishadow(player_ptr)) {
msg_print(_("霊的エネルギーで精神が攻撃された。", "Your mind is blasted by psionic energy."));
-
player_ptr->csp -= 100;
if (player_ptr->csp < 0) {
player_ptr->csp = 0;
player_ptr->csp_frac = 0;
}
- player_ptr->redraw |= PR_MP;
+
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
}
ep_ptr->get_damage = take_hit(player_ptr, DAMAGE_ATTACK, ep_ptr->dam, ep_ptr->killer);
StatusRedrawingFlag::MONSTER_LITE,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
if ((player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].info & CAVE_GLOW) != 0) {
set_superstealth(player_ptr, false);
player_ptr->feeling = new_feeling;
do_cmd_feeling(player_ptr);
select_floor_music(player_ptr);
- player_ptr->redraw |= PR_DEPTH;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::DEPTH);
if (disturb_minor) {
disturb(player_ptr, false, false);
}
StatusRedrawingFlag::MONSTER_LITE,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
}
/*
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "system/terrain-type-definition.h"
#include "timed-effect/player-cut.h"
#include "timed-effect/player-poison.h"
player_ptr->chp_frac = 0;
}
- player_ptr->redraw |= (PR_HP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::HP);
player_ptr->window_flags |= (PW_PLAYER);
if (num < 5) {
msg_print(_("少し気分が良くなった。", "You feel a little better."));
}
if (old_chp != player_ptr->chp) {
- player_ptr->redraw |= (PR_HP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::HP);
player_ptr->window_flags |= (PW_PLAYER);
wild_regen = 20;
}
}
if (old_csp != player_ptr->csp) {
- player_ptr->redraw |= (PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
player_ptr->window_flags |= (PW_PLAYER);
player_ptr->window_flags |= (PW_SPELL);
wild_regen = 20;
m_ptr->hp = m_ptr->maxhp;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == i) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == i) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
}
}
player_ptr->csp_frac = 0;
}
- player_ptr->redraw |= PR_MP;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
}
static void occur_curse_effects(PlayerType *player_ptr)
OBJECT_IDX floor_o_idx = 0;
int can_pickup = 0;
auto &o_idx_list = player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].o_idx_list;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
for (auto it = o_idx_list.begin(); it != o_idx_list.end();) {
const OBJECT_IDX this_o_idx = *it++;
auto *o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
msg_format(mes, (long)o_ptr->pval, item_name.data());
sound(SOUND_SELL);
player_ptr->au += o_ptr->pval;
- player_ptr->redraw |= (PR_GOLD);
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
player_ptr->window_flags |= (PW_PLAYER);
delete_object_idx(player_ptr, this_o_idx);
continue;
verify_panel(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD;
handle_stuff(player_ptr);
auto *g_ptr = &player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x];
msg_format(_(" $%ld の価値がある%sを見つけた。", "You collect %ld gold pieces worth of %s."), (long)value, item_name.data());
sound(SOUND_SELL);
player_ptr->au += value;
- player_ptr->redraw |= (PR_GOLD);
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
player_ptr->window_flags |= (PW_PLAYER);
continue;
}
auto *floor_ptr = player_ptr->current_floor_ptr;
projection_path path_g(player_ptr, (project_length ? project_length : get_max_range(player_ptr)), player_ptr->y, player_ptr->x, y, x, PROJECT_PATH | PROJECT_THRU);
- player_ptr->redraw |= (PR_MAP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MAP);
handle_stuff(player_ptr);
for (const auto &[ny, nx] : path_g) {
auto *g_ptr = &floor_ptr->grid_array[ny][nx];
panel_bounds_center();
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
handle_stuff(player_ptr);
return true;
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= (PR_TITLE);
+ rfu.set_flag(MainWindowRedrawingFlag::TITLE);
break;
}
case KTRL('A'): {
#include "system/dungeon-info.h"
#include "system/floor-type-definition.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "system/system-variables.h"
#include "term/gameterm.h"
#include "term/screen-processor.h"
return nullptr;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
bool old_use_graphics = use_graphics;
if (old_use_graphics) {
/* Clear -more- prompt first */
use_graphics = false;
reset_visuals(player_ptr);
- player_ptr->redraw |= (PR_WIPE | PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIPPY);
+ const auto flags = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::EQUIPPY,
+ };
+ rfu.set_flags(flags);
handle_stuff(player_ptr);
}
use_graphics = true;
reset_visuals(player_ptr);
-
- player_ptr->redraw |= (PR_WIPE | PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIPPY);
+ const auto flags = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::EQUIPPY,
+ };
+ rfu.set_flags(flags);
handle_stuff(player_ptr);
return ret;
}
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- p_ptr->redraw |= (PR_WIPE | PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIPPY);
-
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::WIPE,
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::EQUIPPY,
+ };
+ rfu.set_flags(flags_mwrf);
handle_stuff(p_ptr);
term_redraw();
#include "system/item-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/screen-processor.h"
#include "term/term-color-types.h"
#include "term/z-form.h"
bool exchange_cash(PlayerType *player_ptr)
{
auto change = false;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
for (INVENTORY_IDX i = 0; i <= INVEN_SUB_HAND; i++) {
const auto item_ptr = &player_ptr->inventory_list[i];
const auto r_idx_of_item = static_cast<MonsterRaceId>(item_ptr->pval);
msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)(1000000L * item_ptr->number));
player_ptr->au += 1000000L * item_ptr->number;
- player_ptr->redraw |= (PR_GOLD);
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
vary_item(player_ptr, i, -item_ptr->number);
}
msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)(200000L * item_ptr->number));
player_ptr->au += 200000L * item_ptr->number;
- player_ptr->redraw |= (PR_GOLD);
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
vary_item(player_ptr, i, -item_ptr->number);
}
msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)(100000L * item_ptr->number));
player_ptr->au += 100000L * item_ptr->number;
- player_ptr->redraw |= (PR_GOLD);
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
vary_item(player_ptr, i, -item_ptr->number);
}
constexpr auto mes = _("賞金 %ld＄を手に入れた。", "You get %ldgp.");
msg_format(mes, (long int)((monraces_info[w_ptr->today_mon].level * 50 + 100) * item_ptr->number));
player_ptr->au += (monraces_info[w_ptr->today_mon].level * 50 + 100) * item_ptr->number;
- player_ptr->redraw |= (PR_GOLD);
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
vary_item(player_ptr, i, -item_ptr->number);
}
constexpr auto mes = _("賞金 %ld＄を手に入れた。", "You get %ldgp.");
msg_format(mes, (long int)((monraces_info[w_ptr->today_mon].level * 30 + 60) * item_ptr->number));
player_ptr->au += (monraces_info[w_ptr->today_mon].level * 30 + 60) * item_ptr->number;
- player_ptr->redraw |= (PR_GOLD);
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
vary_item(player_ptr, i, -item_ptr->number);
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
return;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == mam_pp_ptr->m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == mam_pp_ptr->m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "timed-effect/player-blindness.h"
#include "timed-effect/timed-effects.h"
#include "util/string-processor.h"
mane_data->mane_list.push_back({ ms_ptr->thrown_spell, ms_ptr->dam });
mane_data->new_mane = true;
-
- player_ptr->redraw |= PR_IMITATION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::IMITATION);
}
static void process_rememberance(melee_spell_type *ms_ptr)
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
mam_ptr->m_ptr->hp = mam_ptr->m_ptr->maxhp;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == mam_ptr->m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == mam_ptr->m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
if (mam_ptr->see_m && did_heal) {
return;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == mam_ptr->t_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == mam_ptr->t_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
}
#include "status/bad-status-setter.h"
#include "status/base-status.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/screen-processor.h"
#include "timed-effect/player-stun.h"
#include "timed-effect/timed-effects.h"
}
PlayerEnergy(player_ptr).set_player_turn_energy(100);
- player_ptr->redraw |= PR_MP;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
player_ptr->window_flags |= PW_PLAYER | PW_SPELL;
return true;
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "target/grid-selector.h"
#include "target/target-getter.h"
#include "term/screen-processor.h"
player_ptr->csp = std::max(0, player_ptr->csp - player_ptr->msp * 10 / (20 + randint1(10)));
PlayerEnergy(player_ptr).set_player_turn_energy(100);
- set_bits(player_ptr->redraw, PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
set_bits(player_ptr->window_flags, PW_PLAYER | PW_SPELL);
return false;
}
PlayerEnergy(player_ptr).set_player_turn_energy(100);
- set_bits(player_ptr->redraw, PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
set_bits(player_ptr->window_flags, PW_PLAYER | PW_SPELL);
}
player_ptr->csp_frac = 0;
}
- player_ptr->redraw |= (PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
return true;
}
}
player_ptr->tim_sh_touki = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
handle_stuff(player_ptr);
return true;
}
player_ptr->resist_magic = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
player_ptr->multishadow = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
player_ptr->dustrobe = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- player_ptr->redraw |= PR_ACTION;
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
msg_format(_("%sの構えをとった。", "You assume the %s stance."), monk_stances[enum2i(new_stance) - 1].desc);
pc.set_monk_stance(new_stance);
}
}
set_stance(player_ptr, new_stance);
- player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
screen_load();
return true;
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "system/terrain-type-definition.h"
#include "target/projection-path-calculator.h"
#include "target/target-checker.h"
return false;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (!success && one_in_(3)) {
msg_print(_("変わり身失敗！逃げられなかった。", "Kawarimi failed! You couldn't run away."));
ninja_data->kawarimi = false;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
return false;
}
}
ninja_data->kawarimi = false;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
return true;
}
if (!notice) {
return false;
}
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
return true;
}
if (ninja_data && !ninja_data->kawarimi) {
msg_print(_("敵の攻撃に対して敏感になった。", "You are now prepared to evade any attacks."));
ninja_data->kawarimi = true;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
}
break;
player_ptr->csp_frac = 0;
}
- player_ptr->redraw |= PR_MP;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
}
/*!
PlayerClass(player_ptr).set_samurai_stance(new_stance);
}
- player_ptr->redraw |= (PR_ACTION | PR_TIMED_EFFECT);
+ const auto flags = {
+ MainWindowRedrawingFlag::ACTION,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ };
+ rfu.set_flags(flags);
screen_load();
return true;
}
msg_format(_("%s^に反撃した！", "You counterattacked %s!"), m_target_name.data());
do_cmd_attack(player_ptr, monap_ptr->m_ptr->fy, monap_ptr->m_ptr->fx, HISSATSU_COUNTER);
monap_ptr->fear = false;
- player_ptr->redraw |= (PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
}
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags);
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
}
/*!
*/
void do_cmd_snipe(PlayerType *player_ptr)
{
- COMMAND_CODE n = 0;
- bool cast;
-
if (cmd_limit_confused(player_ptr)) {
return;
}
+
if (cmd_limit_image(player_ptr)) {
return;
}
+
if (cmd_limit_stun(player_ptr)) {
return;
}
+ COMMAND_CODE n = 0;
if (!get_snipe_power(player_ptr, &n, false)) {
return;
}
- cast = cast_sniper_spell(player_ptr, n);
-
- if (!cast) {
+ if (!cast_sniper_spell(player_ptr, n)) {
return;
}
- player_ptr->redraw |= (PR_HP | PR_MP);
+
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
+ rfu.set_flags(flags_mwrf);
player_ptr->window_flags |= (PW_PLAYER);
player_ptr->window_flags |= (PW_SPELL);
}
#include "hpmp/hp-mp-processor.h"
#include "player/player-damage.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "view/display-messages.h"
bool comvert_hp_to_mp(PlayerType *player_ptr)
{
constexpr auto mes = _("ＨＰからＭＰへの無謀な変換", "thoughtless conversion from HP to SP");
auto gain_sp = take_hit(player_ptr, DAMAGE_USELIFE, player_ptr->lev, mes) / 5;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ const auto flags = {
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
if (!gain_sp) {
msg_print(_("変換に失敗した。", "You failed to convert."));
- player_ptr->redraw |= (PR_HP | PR_MP);
+ rfu.set_flags(flags);
return true;
}
player_ptr->csp_frac = 0;
}
- player_ptr->redraw |= (PR_HP | PR_MP);
+ rfu.set_flags(flags);
return true;
}
msg_print(_("変換に失敗した。", "You failed to convert."));
}
- player_ptr->redraw |= (PR_HP | PR_MP);
+ const auto flags = {
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
+ RedrawingFlagsUpdater::get_instance().set_flags(flags);
return true;
}
chg_virtue(player_ptr, Virtue::SACRIFICE, 2);
}
- player_ptr->redraw |= (PR_GOLD);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
player_ptr->window_flags |= (PW_PLAYER);
monap_ptr->blinked = true;
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == monap_ptr->m_idx) {
- player_ptr->redraw |= PR_HEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == monap_ptr->m_idx) {
- player_ptr->redraw |= PR_UHEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
monap_ptr->o_ptr->pval = !is_magic_mastery || (monap_ptr->o_ptr->pval == 1) ? 0 : monap_ptr->o_ptr->pval - drain;
monap_ptr->m_ptr->hp = monap_ptr->m_ptr->maxhp;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == monap_ptr->m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == monap_ptr->m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
if (monap_ptr->m_ptr->ml && did_heal) {
player_ptr->csp_frac = 0;
}
- player_ptr->redraw |= (PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
}
/*!
{
w_ptr->total_winner = true;
add_winner_class(player_ptr->pclass);
- player_ptr->redraw |= PR_TITLE;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TITLE);
play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_FINAL_QUEST_CLEAR);
exe_write_diary(player_ptr, DIARY_DESCRIPTION, 0, _("見事に変愚蛮怒の勝利者となった！", "finally became *WINNER* of Hengband!"));
patron_list[player_ptr->chaos_patron].admire(player_ptr);
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "timed-effect/player-hallucination.h"
#include "timed-effect/timed-effects.h"
#include "util/bit-flags-calculator.h"
void MonsterDamageProcessor::set_redraw()
{
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (this->player_ptr->health_who == this->m_idx) {
- this->player_ptr->redraw |= PR_HEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (this->player_ptr->riding == this->m_idx) {
- this->player_ptr->redraw |= PR_UHEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
if (m_ptr->ml) {
if (player_ptr->health_who == m_idx) {
- player_ptr->redraw |= PR_HEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == m_idx) {
- player_ptr->redraw |= PR_UHEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
}
}
if (m_ptr->ml) {
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == m_idx) {
- player_ptr->redraw |= PR_HEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == m_idx) {
- player_ptr->redraw |= PR_UHEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
}
}
if (m_ptr->ml) {
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == m_idx) {
- player_ptr->redraw |= PR_HEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == m_idx) {
- player_ptr->redraw |= PR_UHEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
}
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
w_ptr->timewalk_m_idx = 0;
m_ptr->ml = true;
lite_spot(player_ptr, um_ptr->fy, um_ptr->fx);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == m_idx) {
- player_ptr->redraw |= PR_HEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == m_idx) {
- player_ptr->redraw |= PR_UHEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
if (!player_ptr->effects()->hallucination()->is_hallucinated()) {
um_ptr->m_ptr->ml = false;
lite_spot(player_ptr, um_ptr->fy, um_ptr->fx);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == m_idx) {
- player_ptr->redraw |= PR_HEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
if (player_ptr->riding == m_idx) {
- player_ptr->redraw |= PR_UHEALTH;
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
if (um_ptr->do_disturb && (disturb_pets || um_ptr->m_ptr->is_hostile())) {
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "target/projection-path-calculator.h"
#include "timed-effect/player-blindness.h"
#include "timed-effect/timed-effects.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
#include "world/world.h"
+#include <iterator>
#ifdef JP
#else
#include "monster/monster-description-types.h"
#endif
-#include <iterator>
-
static void set_no_magic_mask(msa_type *msa_ptr)
{
if (!msa_ptr->no_inate) {
mane_data->mane_list.push_back({ msa_ptr->thrown_spell, msa_ptr->dam });
mane_data->new_mane = true;
- player_ptr->redraw |= PR_IMITATION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::IMITATION);
}
static void remember_mspell(msa_type *msa_ptr)
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_MAP | PR_TIMED_EFFECT | PR_ACTION);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ MainWindowRedrawingFlag::ACTION,
+ };
+ rfu.set_flags(flags_mwrf);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
player_ptr->energy_need += ENERGY_NEED();
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "timed-effect/player-blindness.h"
#include "timed-effect/timed-effects.h"
#include "view/display-messages.h"
}
monspell_message_base(player_ptr, m_idx, t_idx, msg, !seen, target_type);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->health_who == m_idx) {
- player_ptr->redraw |= (PR_HEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
}
+
if (player_ptr->riding == m_idx) {
- player_ptr->redraw |= (PR_UHEALTH);
+ rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
}
if (!m_ptr->is_fearful()) {
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "target/target-checker.h"
#include "target/target-setter.h"
#include "target/target-types.h"
if (player_ptr->muta.has(PlayerMutationType::ALCOHOL) && (randint1(6400) == 321)) {
if (!has_resist_conf(player_ptr) && !has_resist_chaos(player_ptr)) {
disturb(player_ptr, false, true);
- player_ptr->redraw |= PR_EXTRA;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::EXTRA);
msg_print(_("いひきがもーろーとひてきたきがふる...ヒック！", "You feel a SSSCHtupor cOmINg over yOu... *HIC*!"));
}
if (player_ptr->muta.has(PlayerMutationType::HALLU) && (randint1(6400) == 42)) {
if (!has_resist_chaos(player_ptr)) {
disturb(player_ptr, false, true);
- player_ptr->redraw |= PR_EXTRA;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::EXTRA);
(void)bss.mod_hallucination(randint0(50) + 20);
}
}
(void)set_invuln(player_ptr, randint1(8) + 8, false);
}
+ const auto flags = {
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
if (player_ptr->muta.has(PlayerMutationType::SP_TO_HP) && one_in_(2000)) {
MANA_POINT wounds = (MANA_POINT)(player_ptr->mhp - player_ptr->chp);
if (wounds > 0) {
hp_player(player_ptr, healing);
player_ptr->csp -= healing;
- player_ptr->redraw |= (PR_HP | PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flags(flags);
}
}
}
player_ptr->csp += healing;
- player_ptr->redraw |= (PR_HP | PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flags(flags);
take_hit(player_ptr, DAMAGE_LOSELIFE, healing, _("頭に昇った血", "blood rushing to the head"));
}
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "target/projection-path-calculator.h"
#include "target/target-checker.h"
#include "target/target-getter.h"
(void)bss.set_blindness(0);
(void)bss.hallucination(0);
set_blessed(player_ptr, randint0(25) + 25, true);
- set_bits(player_ptr->redraw, PR_ABILITY_SCORE);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ABILITY_SCORE);
return true;
}
msg_print(_("手が輝き始めた。", "Your hands begin to glow."));
this->player_ptr->special_attack |= ATTACK_CONFUSE;
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
this->ident = true;
break;
case SV_SCROLL_PROTECTION_FROM_EVIL: {
handle_stuff(player_ptr);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
- player_ptr->redraw |= (PR_EXTRA);
-
- /* Update health track of mount */
- player_ptr->redraw |= (PR_UHEALTH);
-
- bool fall_dam = false;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::UHEALTH,
+ };
+ rfu.set_flags(flags_mwrf);
+ auto fall_dam = false;
if (player_ptr->levitation && !force) {
const auto m_name = monster_desc(player_ptr, m_ptr, 0);
msg_format(_("%sから落ちたが、空中でうまく体勢を立て直して着地した。", "You are thrown from %s but make a good landing."), m_name.data());
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
if (player_ptr->special_attack & ATTACK_CONFUSE) {
player_ptr->special_attack &= ~(ATTACK_CONFUSE);
msg_print(_("手の輝きがなくなった。", "Your hands stop glowing."));
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
}
auto *r_ptr = pa_ptr->r_ptr;
auto sp = damroll(dd, 8);
player_ptr->csp = std::min(player_ptr->msp, player_ptr->csp + sp);
- set_bits(player_ptr->redraw, PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
}
/*!
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- this->player_ptr->redraw |= PR_ACTION;
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::ACTION,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ };
+ rfu.set_flags(flags_mwrf);
this->player_ptr->action = ACTION_NONE;
return true;
}
if (this->player_ptr->stat_top[status] != top) {
this->player_ptr->stat_top[status] = (int16_t)top;
- set_bits(this->player_ptr->redraw, PR_ABILITY_SCORE);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::ABILITY_SCORE);
set_bits(this->player_ptr->window_flags, PW_PLAYER);
}
}
if (this->player_ptr->stat_use[status] != use) {
this->player_ptr->stat_use[status] = (int16_t)use;
- set_bits(this->player_ptr->redraw, PR_ABILITY_SCORE);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::ABILITY_SCORE);
set_bits(this->player_ptr->window_flags, PW_PLAYER);
}
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- player_ptr->redraw |= (PR_HUNGER);
+ rfu.set_flag(MainWindowRedrawingFlag::HUNGER);
handle_stuff(player_ptr);
return true;
player_ptr->chp = 0;
}
- player_ptr->redraw |= PR_HP;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::HP);
player_ptr->window_flags |= PW_PLAYER;
if (damage_type != DAMAGE_GENO && player_ptr->chp == 0) {
if (mpe_mode & MPE_FORGET_FLOW) {
forget_flow(floor_ptr);
rfu.set_flag(StatusRedrawingFlag::UN_VIEW);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
}
const auto flags_srf = {
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) {
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
}
if (player_ptr->see_inv != old_see_inv) {
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
}
if (player_ptr->pspeed != old_speed) {
- set_bits(player_ptr->redraw, PR_SPEED);
+ rfu.set_flag(MainWindowRedrawingFlag::SPEED);
}
if ((player_ptr->dis_ac != old_dis_ac) || (player_ptr->dis_to_a != old_dis_to_a)) {
- set_bits(player_ptr->redraw, PR_AC);
+ rfu.set_flag(MainWindowRedrawingFlag::AC);
set_bits(player_ptr->window_flags, PW_PLAYER);
}
#endif
player_ptr->mhp = mhp;
- player_ptr->redraw |= PR_HP;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::HP);
player_ptr->window_flags |= PW_PLAYER;
}
}
player_ptr->old_spells = player_ptr->new_spells;
- set_bits(player_ptr->redraw, PR_STUDY);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::STUDY);
set_bits(player_ptr->window_flags, PW_ITEM_KNOWLEDGTE);
}
} else {
if (mp_ptr->spell_first > player_ptr->lev) {
player_ptr->msp = 0;
- set_bits(player_ptr->redraw, PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
return;
}
}
#endif
player_ptr->msp = msp;
- set_bits(player_ptr->redraw, PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
}
player_ptr->max_max_exp = player_ptr->max_exp;
}
- set_bits(player_ptr->redraw, PR_EXP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::EXP);
handle_stuff(player_ptr);
PlayerRace pr(player_ptr);
bool android = pr.equals(PlayerRaceType::ANDROID);
PLAYER_LEVEL old_lev = player_ptr->lev;
- auto &rfu = RedrawingFlagsUpdater::get_instance();
const auto flags_srf = {
StatusRedrawingFlag::BONUS,
StatusRedrawingFlag::HP,
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);
- set_bits(player_ptr->redraw, PR_LEVEL | PR_TITLE);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::LEVEL,
+ MainWindowRedrawingFlag::TITLE,
+ };
+ rfu.set_flags(flags_mwrf);
set_bits(player_ptr->window_flags, PW_PLAYER);
handle_stuff(player_ptr);
}
sound(SOUND_LEVEL);
msg_format(_("レベル %d にようこそ。", "Welcome to level %d."), player_ptr->lev);
rfu.set_flags(flags_srf);
- set_bits(player_ptr->redraw, (PR_LEVEL | PR_TITLE | PR_EXP));
+ const auto flags_mwrf_levelup = {
+ MainWindowRedrawingFlag::LEVEL,
+ MainWindowRedrawingFlag::TITLE,
+ MainWindowRedrawingFlag::EXP,
+ };
+ rfu.set_flags(flags_mwrf_levelup);
set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL | PW_INVENTORY));
player_ptr->level_up_message = true;
handle_stuff(player_ptr);
}
rfu.set_flags(flags_srf);
- set_bits(player_ptr->redraw, (PR_LEVEL | PR_TITLE));
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::LEVEL,
+ MainWindowRedrawingFlag::TITLE,
+ };
+ rfu.set_flags(flags_mwrf);
set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
handle_stuff(player_ptr);
}
player_ptr->tsubureru = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
#include "spell/spells-summon.h"
#include "status/shape-changer.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "target/target-getter.h"
#include "view/display-messages.h"
if (!(player_ptr->special_attack & ATTACK_CONFUSE)) {
msg_print(_("あなたの手は光り始めた。", "Your hands start glowing."));
player_ptr->special_attack |= ATTACK_CONFUSE;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
}
}
}
StatusRedrawingFlag::SPELLS,
};
rfu.set_flags(flags);
- player_ptr->redraw |= (PR_EXTRA);
-
+ rfu.set_flag(MainWindowRedrawingFlag::EXTRA);
return "";
}
}
StatusRedrawingFlag::SPELLS,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_EXTRA | PR_HP | PR_MP);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
+ rfu.set_flags(flags_mwrf);
}
return "";
}
command_dir = 0;
- player_ptr->redraw |= PR_MP;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
handle_stuff(player_ptr);
} while (player_ptr->csp > mana_cost_per_monster);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
}
/*!
if (cast) {
msg_print(_("フィンゴルフィンの冥王への挑戦を歌った．．．", "You recall the valor of Fingolfin's challenge to the Dark Lord..."));
-
- player_ptr->redraw |= (PR_MAP);
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
+ rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
-
start_singing(player_ptr, spell, MUSIC_INVULN);
}
if (stop) {
if (!player_ptr->invuln) {
msg_print(_("無敵ではなくなった。", "The invulnerability wears off."));
-
- player_ptr->redraw |= (PR_MAP);
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
+ rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
}
}
#include "status/element-resistance.h"
#include "system/item-entity.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "view/display-messages.h"
if (!PlayerClass(player_ptr).equals(PlayerClassType::SAMURAI) && (death_scythe_flags.has(TR_FORCE_WEAPON)) && (player_ptr->csp > (player_ptr->msp / 30))) {
player_ptr->csp -= (1 + (player_ptr->msp / 30));
- player_ptr->redraw |= (PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
*magnification = *magnification * 3 / 2 + 20;
}
}
#include "spell-kind/spells-perception.h"
#include "status/bad-status-setter.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "view/display-messages.h"
return;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (this->player_ptr->csp >= 20) {
this->player_ptr->csp -= 20;
- set_bits(this->player_ptr->redraw, PR_MP);
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
return;
}
BadStatusSetter bss(this->player_ptr);
(void)bss.mod_paralysis(randint1(5 * oops + 1));
(void)bss.mod_confusion(randint1(5 * oops + 1));
- set_bits(this->player_ptr->redraw, PR_MP);
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
}
#include "system/grid-type-definition.h"
#include "system/monster-entity.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "system/terrain-type-definition.h"
#include "target/grid-selector.h"
#include "target/projection-path-calculator.h"
this->player_ptr->csp_frac = 0;
}
- set_bits(this->player_ptr->redraw, PR_MP);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
return true;
}
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_HEALTH | PR_UHEALTH | PR_MAP);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::HEALTH,
+ MainWindowRedrawingFlag::UHEALTH,
+ MainWindowRedrawingFlag::MAP,
+ };
+ rfu.set_flags(flags_mwrf);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
if (floor_ptr->grid_array[player_ptr->y][player_ptr->x].info & CAVE_GLOW) {
set_superstealth(player_ptr, false);
const auto item_name = describe_flavor(player_ptr, o_ptr, OD_NAME_ONLY);
msg_format(_("%s^があなたの足元に飛んできた。", "%s^ flies through the air to your feet."), item_name.data());
note_spot(player_ptr, player_ptr->y, player_ptr->x);
- player_ptr->redraw |= PR_MAP;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MAP);
}
bool fetch_monster(PlayerType *player_ptr)
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON | PW_FOUND_ITEMS);
if (player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].info & CAVE_GLOW) {
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON | PW_FOUND_ITEMS);
}
}
}
- player_ptr->redraw |= (PR_MAP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
}
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
if (floor_ptr->grid_array[player_ptr->y][player_ptr->x].info & CAVE_GLOW) {
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/bit-flags-calculator.h"
#include "view/display-messages.h"
}
move_cursor_relative(player_ptr->y, player_ptr->x);
- player_ptr->redraw |= (PR_HP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::HP);
player_ptr->window_flags |= (PW_PLAYER);
handle_stuff(player_ptr);
term_fresh();
bool dummy = project(player_ptr, 0, 1, player_ptr->y, player_ptr->x, 0, AttributeType::STONE_WALL, flg).notice;
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::FLOW);
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
return dummy;
}
#include "system/monster-entity.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "target/projection-path-calculator.h"
#include "target/target-checker.h"
#include "target/target-setter.h"
return;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->alter_reality || turns == 0) {
player_ptr->alter_reality = 0;
msg_print(_("景色が元に戻った...", "The view around you returns to normal..."));
- player_ptr->redraw |= PR_TIMED_EFFECT;
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
return;
}
player_ptr->alter_reality = turns;
msg_print(_("回りの景色が変わり始めた...", "The view around you begins to change..."));
- player_ptr->redraw |= PR_TIMED_EFFECT;
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
}
/*!
}
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (player_ptr->word_recall || turns == 0) {
player_ptr->word_recall = 0;
msg_print(_("張りつめた大気が流れ去った...", "A tension leaves the air around you..."));
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
return true;
}
player_ptr->word_recall = turns;
msg_print(_("回りの大気が張りつめてきた...", "The air about you becomes charged..."));
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
return true;
}
}
msg_print(_("回りの大気が張りつめてきた...", "The air about you becomes charged..."));
-
- player_ptr->redraw |= PR_TIMED_EFFECT;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
return true;
}
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
return true;
}
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
player_ptr->tim_sh_holy = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
auto &rfu = RedrawingFlagsUpdater::get_instance();
player_ptr->tim_eyeeye = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
player_ptr->tim_sh_fire = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
StatusRedrawingFlag::SPELLS,
};
rfu.set_flags(flags_srf);
- this->player_ptr->redraw |= PR_EXTRA | PR_HP | PR_MP;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
+ rfu.set_flags(flags_mwrf);
}
/*!
StatusRedrawingFlag::SPELLS,
};
rfu.set_flags(flags_srf);
- this->player_ptr->redraw |= PR_EXTRA | PR_HP | PR_MP;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ };
+ rfu.set_flags(flags_mwrf);
return is_selected;
}
}
s64b_sub(&(this->player_ptr->csp), &(this->player_ptr->csp_frac), need_mana, need_mana_frac);
- this->player_ptr->redraw |= PR_MP;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
if (!need_restart) {
return true;
}
msg_print(_("詠唱を再開した。", "You restart casting."));
this->player_ptr->action = ACTION_SPELL;
- auto &rfu = RedrawingFlagsUpdater::get_instance();
const auto flags_srf = {
StatusRedrawingFlag::BONUS,
StatusRedrawingFlag::HP,
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- this->player_ptr->redraw |= PR_MAP | PR_TIMED_EFFECT | PR_ACTION;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ MainWindowRedrawingFlag::ACTION,
+ };
+ rfu.set_flags(flags_mwrf);
this->player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
return true;
}
if (s64b_cmp(player_ptr->csp, player_ptr->csp_frac, need_mana, need_mana_frac) < 0) {
stop_singing(player_ptr);
return;
- } else {
- s64b_sub(&(player_ptr->csp), &(player_ptr->csp_frac), need_mana, need_mana_frac);
-
- player_ptr->redraw |= PR_MP;
- if (interupting_song_effect != 0) {
- set_singing_song_effect(player_ptr, interupting_song_effect);
- set_interrupting_song_effect(player_ptr, MUSIC_NONE);
- msg_print(_("歌を再開した。", "You resume singing."));
- player_ptr->action = ACTION_SING;
- auto &rfu = RedrawingFlagsUpdater::get_instance();
- const auto flags_srf = {
- StatusRedrawingFlag::BONUS,
- StatusRedrawingFlag::HP,
- StatusRedrawingFlag::MONSTER_STATUSES,
- };
- rfu.set_flags(flags_srf);
- player_ptr->redraw |= (PR_MAP | PR_TIMED_EFFECT | PR_ACTION);
- player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
- }
}
- PlayerSkill(player_ptr).gain_continuous_spell_skill_exp(REALM_MUSIC, spell);
+ s64b_sub(&(player_ptr->csp), &(player_ptr->csp_frac), need_mana, need_mana_frac);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
+ if (interupting_song_effect != 0) {
+ set_singing_song_effect(player_ptr, interupting_song_effect);
+ set_interrupting_song_effect(player_ptr, MUSIC_NONE);
+ msg_print(_("歌を再開した。", "You resume singing."));
+ player_ptr->action = ACTION_SING;
+ const auto flags_srf = {
+ StatusRedrawingFlag::BONUS,
+ StatusRedrawingFlag::HP,
+ StatusRedrawingFlag::MONSTER_STATUSES,
+ };
+ rfu.set_flags(flags_srf);
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ MainWindowRedrawingFlag::ACTION,
+ };
+ rfu.set_flags(flags_mwrf);
+ player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
+ }
+ PlayerSkill(player_ptr).gain_continuous_spell_skill_exp(REALM_MUSIC, spell);
exe_spell(player_ptr, REALM_MUSIC, spell, SpellProcessType::CONTNUATION);
}
player_ptr->tim_stealth = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
set_singing_song_id(player_ptr, 0);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- set_bits(player_ptr->redraw, PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
}
bool music_singing(PlayerType *player_ptr, int music_songs)
#include "object/object-value.h"
#include "system/item-entity.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "term/z-form.h"
#include "view/display-messages.h"
msg_format(_("%sを＄%d の金に変えた。", "You turn %s to %d coins worth of gold."), item_name.data(), price);
player_ptr->au += price;
- player_ptr->redraw |= PR_GOLD;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::GOLD);
player_ptr->window_flags |= PW_PLAYER;
vary_item(player_ptr, item, -amt);
return true;
player_ptr->energy_need -= 1000 + (100 + player_ptr->csp - 50) * TURNS_PER_TICK / 10;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
handle_stuff(player_ptr);
auto percent = (player_ptr->player_hp[PY_MAX_LEVEL - 1] * 200) / (2 * player_ptr->hitdie + ((PY_MAX_LEVEL - 1 + 3) * (player_ptr->hitdie + 1)));
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::HP);
- player_ptr->redraw |= (PR_HP);
+ rfu.set_flag(MainWindowRedrawingFlag::HP);
player_ptr->window_flags |= (PW_PLAYER);
if (!(options & SPOP_NO_UPDATE)) {
player_ptr->csp = player_ptr->msp;
player_ptr->csp_frac = 0;
msg_print(_("頭がハッキリとした。", "You feel your head clear."));
- player_ptr->redraw |= (PR_MP);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
player_ptr->window_flags |= (PW_PLAYER);
player_ptr->window_flags |= (PW_SPELL);
return true;
}
set_action(player_ptr, ACTION_FISH);
- player_ptr->redraw |= (PR_ACTION);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
return true;
}
switch (prev_typ) {
case ACTION_SEARCH:
msg_print(_("探索をやめた。", "You no longer walk carefully."));
- player_ptr->redraw |= (PR_SPEED);
+ rfu.set_flag(MainWindowRedrawingFlag::SPEED);
break;
case ACTION_REST:
player_ptr->resting = 0;
msg_print(_("型を崩した。", "You stop assuming the special stance."));
PlayerClass(player_ptr).set_samurai_stance(SamuraiStanceType::NONE);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
break;
case ACTION_SING:
msg_print(_("歌うのをやめた。", "You stop singing."));
switch (player_ptr->action) {
case ACTION_SEARCH:
msg_print(_("注意深く歩き始めた。", "You begin to walk carefully."));
- player_ptr->redraw |= (PR_SPEED);
+ rfu.set_flag(MainWindowRedrawingFlag::SPEED);
break;
case ACTION_LEARN:
msg_print(_("学習を始めた。", "You begin learning"));
}
rfu.set_flag(StatusRedrawingFlag::BONUS);
- player_ptr->redraw |= (PR_ACTION);
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
}
}
blindness->set(v);
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
StatusRedrawingFlag::MONSTER_STATUSES,
StatusRedrawingFlag::MONSTER_LITE,
};
- auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flags(flags_srf);
- this->player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
this->player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
handle_stuff(this->player_ptr);
return true;
return false;
}
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
auto is_confused = this->player_confusion->is_confused();
if (v > 0) {
if (!is_confused) {
msg_print(_("あなたは混乱した！", "You are confused!"));
- auto &rfu = RedrawingFlagsUpdater::get_instance();
if (this->player_ptr->action == ACTION_LEARN) {
msg_print(_("学習が続けられない！", "You cannot continue learning!"));
auto bluemage_data = PlayerClass(player_ptr).get_specific_data<bluemage_data_type>();
bluemage_data->new_magic_learned = false;
-
- this->player_ptr->redraw |= PR_ACTION;
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
this->player_ptr->action = ACTION_NONE;
}
if (this->player_ptr->action == ACTION_MONK_STANCE) {
msg_print(_("構えがとけた。", "You lose your stance."));
PlayerClass(player_ptr).set_monk_stance(MonkStanceType::NONE);
rfu.set_flag(StatusRedrawingFlag::BONUS);
- this->player_ptr->redraw |= PR_ACTION;
+ rfu.set_flag(MainWindowRedrawingFlag::ACTION);
this->player_ptr->action = ACTION_NONE;
} else if (this->player_ptr->action == ACTION_SAMURAI_STANCE) {
msg_print(_("型が崩れた。", "You lose your stance."));
}
this->player_confusion->set(v);
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
}
player_poison->set(v);
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
}
fear->set(v);
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
}
paralysis->set(v);
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
disturb(this->player_ptr, false, false);
}
- this->player_ptr->redraw |= PR_ACTION;
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::ACTION);
handle_stuff(this->player_ptr);
return true;
}
}
hallucination->set(v);
- this->player_ptr->redraw |= PR_TIMED_EFFECT;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
disturb(this->player_ptr, false, true);
}
- auto &rfu = RedrawingFlagsUpdater::get_instance();
- this->player_ptr->redraw |= PR_MAP | PR_HEALTH | PR_UHEALTH;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::MAP,
+ MainWindowRedrawingFlag::HEALTH,
+ MainWindowRedrawingFlag::UHEALTH,
+ };
+ rfu.set_flags(flags_mwrf);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
this->player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
handle_stuff(this->player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- this->player_ptr->redraw |= PR_STUN;
+ rfu.set_flag(MainWindowRedrawingFlag::STUN);
handle_stuff(this->player_ptr);
return true;
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- this->player_ptr->redraw |= PR_CUT;
+ rfu.set_flag(MainWindowRedrawingFlag::CUT);
handle_stuff(this->player_ptr);
return true;
}
player_ptr->stat_cur[stat] = cur;
player_ptr->stat_max[stat] = max;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_ABILITY_SCORE);
+ rfu.set_flag(MainWindowRedrawingFlag::ABILITY_SCORE);
rfu.set_flag(StatusRedrawingFlag::BONUS);
}
player_ptr->stat_cur[stat] = player_ptr->stat_max[stat];
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::BONUS);
- player_ptr->redraw |= (PR_ABILITY_SCORE);
+ rfu.set_flag(MainWindowRedrawingFlag::ABILITY_SCORE);
return true;
}
}
player_ptr->protevil = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
chg_virtue(player_ptr, Virtue::HONOUR, -2);
chg_virtue(player_ptr, Virtue::SACRIFICE, -3);
chg_virtue(player_ptr, Virtue::VALOUR, -5);
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
}
if (player_ptr->invuln && !music_singing(player_ptr, MUSIC_INVULN)) {
msg_print(_("無敵ではなくなった。", "The invulnerability wears off."));
notice = true;
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
player_ptr->energy_need += ENERGY_NEED();
}
player_ptr->invuln = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
player_ptr->tim_regen = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
disturb(player_ptr, false, false);
}
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::BONUS);
+ rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
return true;
}
}
player_ptr->tim_reflect = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
disturb(player_ptr, false, false);
}
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::BONUS);
+ rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
return true;
}
}
player_ptr->tim_pass_wall = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
disturb(player_ptr, false, false);
}
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::BONUS);
+ rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
return true;
}
}
player_ptr->shield = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
if (disturb_state) {
disturb(player_ptr, false, false);
}
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::BONUS);
+
+ rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
return true;
}
}
player_ptr->magicdef = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
disturb(player_ptr, false, false);
}
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::BONUS);
+ rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
return true;
}
}
player_ptr->blessed = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
disturb(player_ptr, false, false);
}
- RedrawingFlagsUpdater::get_instance().set_flag(StatusRedrawingFlag::BONUS);
+ rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
return true;
}
}
player_ptr->hero = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
}
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_BASIC | PR_TIMED_EFFECT);
- const auto flags = {
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::TIMED_EFFECT,
+ };
+ rfu.set_flags(flags_mwrf);
+ const auto flags_srf = {
StatusRedrawingFlag::BONUS,
StatusRedrawingFlag::HP,
};
- rfu.set_flags(flags);
+ rfu.set_flags(flags_srf);
handle_stuff(player_ptr);
return true;
}
}
player_ptr->shero = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
chg_virtue(player_ptr, Virtue::HONOUR, -2);
chg_virtue(player_ptr, Virtue::SACRIFICE, -2);
chg_virtue(player_ptr, Virtue::VALOUR, -5);
-
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
}
if (player_ptr->wraith_form) {
msg_print(_("不透明になった感じがする。", "You feel opaque."));
notice = true;
-
- player_ptr->redraw |= (PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
player_ptr->window_flags |= (PW_OVERHEAD | PW_DUNGEON);
}
}
player_ptr->wraith_form = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
return true;
}
}
- auto &rfu = RedrawingFlagsUpdater::get_instance();
player_ptr->tsuyoshi = v;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
-
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
#include "realm/realm-song-numbers.h"
#include "spell-realm/spells-song.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "view/display-messages.h"
/*!
}
player_ptr->oppose_acid = v;
-
if (!notice) {
return false;
}
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
handle_stuff(player_ptr);
return true;
}
}
player_ptr->oppose_elec = v;
-
if (!notice) {
return false;
}
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
handle_stuff(player_ptr);
return true;
}
}
player_ptr->oppose_fire = v;
-
if (!notice) {
return false;
}
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
handle_stuff(player_ptr);
return true;
}
}
player_ptr->oppose_cold = v;
-
if (!notice) {
return false;
}
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
handle_stuff(player_ptr);
return true;
}
if (!notice) {
return false;
}
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (disturb_state) {
disturb(player_ptr, false, false);
}
+
handle_stuff(player_ptr);
return true;
}
roll_hitdice(player_ptr, SPOP_NONE);
check_experience(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_BASIC);
+ rfu.set_flag(MainWindowRedrawingFlag::BASIC);
rfu.set_flag(StatusRedrawingFlag::BONUS);
handle_stuff(player_ptr);
static bool update_sight(PlayerType *player_ptr, const bool notice)
{
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
player_ptr->tim_levitation = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
player_ptr->ult_res = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
player_ptr->tim_res_nether = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
player_ptr->tim_res_time = v;
auto &rfu = RedrawingFlagsUpdater::get_instance();
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ rfu.set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (!notice) {
return false;
}
StatusRedrawingFlag::MONSTER_STATUSES,
};
rfu.set_flags(flags_srf);
- player_ptr->redraw |= PR_BASIC | PR_EXTRA | PR_EQUIPPY;
- player_ptr->redraw |= PR_MAP;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::EXTRA,
+ MainWindowRedrawingFlag::EQUIPPY,
+ MainWindowRedrawingFlag::MAP,
+ };
+ rfu.set_flags(flags_mwrf);
player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
}
POSITION cur_lite{}; /* Radius of lite (if any) */
- BIT_FLAGS redraw{}; /* Normal Redraws */
BIT_FLAGS window_flags{}; /* Window Redraws */
int16_t stat_use[A_MAX]{}; /* Current modified stats */
int16_t stat_top[A_MAX]{}; /* Maximal modified stats */
verify_panel(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD;
handle_stuff(player_ptr);
} else {
verify_panel(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD;
handle_stuff(player_ptr);
*x_ptr = info.x;
panel_bounds_center();
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD | PW_DUNGEON;
}
verify_panel(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD;
handle_stuff(player_ptr);
target_set_prepare(player_ptr, ys_interest, xs_interest, ts_ptr->mode);
panel_col_min = ts_ptr->x2;
panel_bounds_center();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD;
handle_stuff(player_ptr);
target_set_prepare(player_ptr, ys_interest, xs_interest, ts_ptr->mode);
verify_panel(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- player_ptr->redraw |= PR_MAP;
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
player_ptr->window_flags |= PW_OVERHEAD;
handle_stuff(player_ptr);
target_set_prepare(player_ptr, ys_interest, xs_interest, ts_ptr->mode);
verify_panel(player_ptr);
auto &rfu = RedrawingFlagsUpdater::get_instance();
rfu.set_flag(StatusRedrawingFlag::MONSTER_STATUSES);
- set_bits(player_ptr->redraw, PR_MAP);
+ rfu.set_flag(MainWindowRedrawingFlag::MAP);
set_bits(player_ptr->window_flags, PW_OVERHEAD | PW_FLOOR_ITEMS);
handle_stuff(player_ptr);
return target_who != 0;
static void change_birth_flags(PlayerType *player_ptr)
{
auto &rfu = RedrawingFlagsUpdater::get_instance();
- const auto &flags_srf = EnumClassFlagGroup<StatusRedrawingFlag>{
+ const auto flags_srf = {
StatusRedrawingFlag::BONUS,
StatusRedrawingFlag::HP,
StatusRedrawingFlag::MP,
};
player_ptr->window_flags |= PW_PLAYER;
rfu.set_flags(flags_srf);
- player_ptr->redraw |= PR_BASIC | PR_HP | PR_MP | PR_ABILITY_SCORE;
+ const auto flags_mwrf = {
+ MainWindowRedrawingFlag::BASIC,
+ MainWindowRedrawingFlag::HP,
+ MainWindowRedrawingFlag::MP,
+ MainWindowRedrawingFlag::ABILITY_SCORE,
+ };
+ rfu.set_flags(flags_mwrf);
}
/*!
#include "system/floor-type-definition.h"
#include "system/monster-race-info.h"
#include "system/player-type-definition.h"
+#include "system/redrawing-flags-updater.h"
#include "util/enum-range.h"
#include "view/display-messages.h"
#include "world/world.h"
}
player_ptr->word_recall--;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (player_ptr->word_recall != 0) {
return;
}
}
player_ptr->alter_reality--;
- player_ptr->redraw |= (PR_TIMED_EFFECT);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::TIMED_EFFECT);
if (player_ptr->alter_reality != 0) {
return;
}
OSDN Git Service
