-#include "player/player-status.h"
+#include "player/player-status.h"
#include "artifact/fixed-art-types.h"
#include "autopick/autopick-reader-writer.h"
#include "autopick/autopick.h"
#include "cmd-item/cmd-magiceat.h"
#include "combat/attack-power-table.h"
#include "core/asking-player.h"
-#include "core/player-redraw-types.h"
-#include "core/player-update-types.h"
#include "core/stuff-handler.h"
#include "core/window-redrawer.h"
#include "dungeon/dungeon-flag-types.h"
#include "object-enchant/tr-types.h"
#include "object-enchant/trc-types.h"
#include "object-hook/hook-armor.h"
-#include "object/object-flags.h"
#include "object/object-info.h"
#include "object/object-mark-types.h"
#include "perception/object-perception.h"
#include "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 "term/screen-processor.h"
#include "timed-effect/player-acceleration.h"
#include "timed-effect/timed-effects.h"
#include "util/bit-flags-calculator.h"
#include "util/enum-converter.h"
-#include "util/quarks.h"
#include "util/string-processor.h"
#include "view/display-messages.h"
#include "world/world.h"
for (int i = 0; i < floor_ptr->redraw_n; i++) {
POSITION y = floor_ptr->redraw_y[i];
POSITION x = floor_ptr->redraw_x[i];
- grid_type *g_ptr;
+ Grid *g_ptr;
g_ptr = &floor_ptr->grid_array[y][x];
if (none_bits(g_ptr->info, CAVE_REDRAW)) {
continue;
ItemEntity *o_ptr;
for (int i = 0; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
weight += o_ptr->weight * o_ptr->number;
player_ptr->anti_magic = has_anti_magic(player_ptr);
player_ptr->anti_tele = has_anti_tele(player_ptr);
player_ptr->easy_spell = has_easy_spell(player_ptr);
- player_ptr->heavy_spell = has_heavy_spell(player_ptr);
+ player_ptr->hard_spell = has_hard_spell(player_ptr);
player_ptr->hold_exp = has_hold_exp(player_ptr);
player_ptr->see_inv = has_see_inv(player_ptr);
player_ptr->free_act = has_free_act(player_ptr);
update_ability_scores(player_ptr);
o_ptr = &player_ptr->inventory_list[INVEN_BOW];
- if (o_ptr->bi_id) {
+ if (o_ptr->is_valid()) {
player_ptr->tval_ammo = o_ptr->get_arrow_kind();
player_ptr->num_fire = calc_num_fire(player_ptr, o_ptr);
}
player_ptr->dis_ac = calc_base_ac(player_ptr);
player_ptr->dis_to_a = calc_to_ac(player_ptr, false);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
if (old_mighty_throw != player_ptr->mighty_throw) {
- player_ptr->window_flags |= PW_INVEN;
+ rfu.set_flag(SubWindowRedrawingFlag::INVENTORY);
}
if (player_ptr->telepathy != old_telepathy) {
- set_bits(player_ptr->update, PU_MONSTERS);
+ RedrawingFlagsUpdater::get_instance().set_flag(StatusRecalculatingFlag::MONSTER_STATUSES);
}
auto is_esp_updated = player_ptr->esp_animal != old_esp_animal;
is_esp_updated |= player_ptr->esp_nonliving != old_esp_nonliving;
is_esp_updated |= player_ptr->esp_unique != old_esp_unique;
if (is_esp_updated) {
- set_bits(player_ptr->update, PU_MONSTERS);
+ rfu.set_flag(StatusRecalculatingFlag::MONSTER_STATUSES);
}
if (player_ptr->see_inv != old_see_inv) {
- set_bits(player_ptr->update, PU_MONSTERS);
+ rfu.set_flag(StatusRecalculatingFlag::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_ARMOR);
- set_bits(player_ptr->window_flags, PW_PLAYER);
+ rfu.set_flag(MainWindowRedrawingFlag::AC);
+ rfu.set_flag(SubWindowRedrawingFlag::PLAYER);
}
if (w_ptr->character_xtra) {
#endif
player_ptr->mhp = mhp;
- player_ptr->redraw |= PR_HP;
- player_ptr->window_flags |= PW_PLAYER;
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::HP);
+ rfu.set_flag(SubWindowRedrawingFlag::PLAYER);
}
/*!
return;
}
- concptr p = spell_category_name(mp_ptr->spell_book);
+ const auto spell_category = spell_category_name(mp_ptr->spell_book);
int levels = player_ptr->lev - mp_ptr->spell_first + 1;
if (levels < 0) {
levels = 0;
const auto spell_name = exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME);
#ifdef JP
- msg_format("%sの%sを忘れてしまった。", spell_name->data(), p);
+ msg_format("%sの%sを忘れてしまった。", spell_name->data(), spell_category.data());
#else
- msg_format("You have forgotten the %s of %s.", p, spell_name->data());
+ msg_format("You have forgotten the %s of %s.", spell_category.data(), spell_name->data());
#endif
player_ptr->new_spells++;
}
const auto spell_name = exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME);
#ifdef JP
- msg_format("%sの%sを忘れてしまった。", spell_name->data(), p);
+ msg_format("%sの%sを忘れてしまった。", spell_name->data(), spell_category.data());
#else
- msg_format("You have forgotten the %s of %s.", p, spell_name->data());
+ msg_format("You have forgotten the %s of %s.", spell_category.data(), spell_name->data());
#endif
player_ptr->new_spells++;
}
const auto spell_name = exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME);
#ifdef JP
- msg_format("%sの%sを思い出した。", spell_name->data(), p);
+ msg_format("%sの%sを思い出した。", spell_name->data(), spell_category.data());
#else
- msg_format("You have remembered the %s of %s.", p, spell_name->data());
+ msg_format("You have remembered the %s of %s.", spell_category.data(), spell_name->data());
#endif
player_ptr->new_spells--;
}
if (player_ptr->new_spells) {
#ifdef JP
if (player_ptr->new_spells < 10) {
- msg_format("あと %d つの%sを学べる。", player_ptr->new_spells, p);
+ msg_format("あと %d つの%sを学べる。", player_ptr->new_spells, spell_category.data());
} else {
- msg_format("あと %d 個の%sを学べる。", player_ptr->new_spells, p);
+ msg_format("あと %d 個の%sを学べる。", player_ptr->new_spells, spell_category.data());
}
#else
- msg_format("You can learn %d more %s%s.", player_ptr->new_spells, p, (player_ptr->new_spells != 1) ? "s" : "");
+ msg_format("You can learn %d more %s%s.", player_ptr->new_spells, spell_category.data(), (player_ptr->new_spells != 1) ? "s" : "");
#endif
}
player_ptr->old_spells = player_ptr->new_spells;
- set_bits(player_ptr->redraw, PR_STUDY);
- set_bits(player_ptr->window_flags, PW_OBJECT);
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::STUDY);
+ rfu.set_flag(SubWindowRedrawingFlag::ITEM_KNOWLEDGE);
}
/*!
} else {
if (mp_ptr->spell_first > player_ptr->lev) {
player_ptr->msp = 0;
- set_bits(player_ptr->redraw, PR_MANA);
+ RedrawingFlagsUpdater::get_instance().set_flag(MainWindowRedrawingFlag::MP);
return;
}
if (any_bits(mp_ptr->spell_xtra, extra_magic_glove_reduce_mana)) {
player_ptr->cumber_glove = false;
- auto *o_ptr = &player_ptr->inventory_list[INVEN_ARMS];
- auto flags = object_flags(o_ptr);
- auto should_mp_decrease = o_ptr->bi_id != 0;
+ const auto *o_ptr = &player_ptr->inventory_list[INVEN_ARMS];
+ const auto flags = o_ptr->get_flags();
+ auto should_mp_decrease = o_ptr->is_valid();
should_mp_decrease &= flags.has_not(TR_FREE_ACT);
should_mp_decrease &= flags.has_not(TR_DEC_MANA);
should_mp_decrease &= flags.has_not(TR_EASY_SPELL);
}
#endif
player_ptr->msp = msp;
- set_bits(player_ptr->redraw, PR_MANA);
- set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ rfu.set_flag(MainWindowRedrawingFlag::MP);
+ static constexpr auto flags = {
+ SubWindowRedrawingFlag::PLAYER,
+ SubWindowRedrawingFlag::SPELL,
+ };
+ rfu.set_flags(flags);
}
if (w_ptr->character_xtra) {
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
ItemEntity *q_ptr;
q_ptr = &player_ptr->inventory_list[i];
- if (!q_ptr->bi_id) {
+ if (!q_ptr->is_valid()) {
continue;
}
continue;
}
- auto flags = object_flags(q_ptr);
- if (flags.has(TR_XTRA_SHOTS)) {
+ if (q_ptr->get_flags().has(TR_XTRA_SHOTS)) {
extra_shots++;
}
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_XTRA_SHOTS)) {
+ if (o_ptr->get_flags().has(TR_XTRA_SHOTS)) {
extra_shots++;
}
int num = 0;
- if (o_ptr->bi_id == 0) {
+ if (!o_ptr->is_valid()) {
return (int16_t)num;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_MAGIC_MASTERY)) {
+
+ if (o_ptr->get_flags().has(TR_MAGIC_MASTERY)) {
pow += 8 * o_ptr->pval;
}
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_SEARCH)) {
+
+ if (o_ptr->get_flags().has(TR_SEARCH)) {
pow += (o_ptr->pval * 5);
}
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_SEARCH)) {
+
+ if (o_ptr->get_flags().has(TR_SEARCH)) {
pow += (o_ptr->pval * 5);
}
}
pow = 0;
- if (PlayerRace(player_ptr).equals(PlayerRaceType::ENT) && !player_ptr->inventory_list[INVEN_MAIN_HAND].bi_id) {
+ if (PlayerRace(player_ptr).equals(PlayerRaceType::ENT) && !player_ptr->inventory_list[INVEN_MAIN_HAND].is_valid()) {
pow += player_ptr->lev * 10;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
- auto flags = object_flags(o_ptr);
- if (flags.has(TR_TUNNEL)) {
+
+ if (o_ptr->get_flags().has(TR_TUNNEL)) {
pow += (o_ptr->pval * 20);
}
}
static int16_t calc_num_blow(PlayerType *player_ptr, int i)
{
- ItemEntity *o_ptr;
int16_t num_blow = 1;
- o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
- auto flags = object_flags(o_ptr);
+ const auto *o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
PlayerClass pc(player_ptr);
if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i)) {
- if (o_ptr->bi_id && !player_ptr->heavy_wield[i]) {
+ if (o_ptr->is_valid() && !player_ptr->heavy_wield[i]) {
int str_index, dex_index;
int num = 0, wgt = 0, mul = 0, div = 0;
wgt = info.wgt;
mul = info.mul;
- if (pc.equals(PlayerClassType::CAVALRY) && player_ptr->riding && flags.has(TR_RIDING)) {
+ if (pc.equals(PlayerClassType::CAVALRY) && player_ptr->riding && o_ptr->get_flags().has(TR_RIDING)) {
num = 5;
wgt = 70;
mul = 4;
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
ac += o_ptr->ac;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
- ItemEntity *o_ptr;
- o_ptr = &player_ptr->inventory_list[i];
- auto flags = object_flags(o_ptr);
- if (!o_ptr->bi_id) {
+ const auto *o_ptr = &player_ptr->inventory_list[i];
+ const auto flags = o_ptr->get_flags();
+ if (!o_ptr->is_valid()) {
continue;
}
if (is_real_value || o_ptr->is_known()) {
ac += o_ptr->to_a;
}
- if (o_ptr->curse_flags.has(CurseTraitType::LOW_AC) || object_flags(o_ptr).has(TR_LOW_AC)) {
+ if (o_ptr->curse_flags.has(CurseTraitType::LOW_AC) || flags.has(TR_LOW_AC)) {
if (o_ptr->curse_flags.has(CurseTraitType::HEAVY_CURSE)) {
if (is_real_value || o_ptr->is_fully_known()) {
ac -= 30;
}
if (pc.is_martial_arts_pro() && !heavy_armor(player_ptr)) {
- if (!(player_ptr->inventory_list[INVEN_BODY].bi_id)) {
+ if (!player_ptr->inventory_list[INVEN_BODY].is_valid()) {
ac += (player_ptr->lev * 3) / 2;
}
- if (!(player_ptr->inventory_list[INVEN_OUTER].bi_id) && (player_ptr->lev > 15)) {
+ if (!player_ptr->inventory_list[INVEN_OUTER].is_valid() && (player_ptr->lev > 15)) {
ac += ((player_ptr->lev - 13) / 3);
}
- if (!(player_ptr->inventory_list[INVEN_SUB_HAND].bi_id) && (player_ptr->lev > 10)) {
+ if (!player_ptr->inventory_list[INVEN_SUB_HAND].is_valid() && (player_ptr->lev > 10)) {
ac += ((player_ptr->lev - 8) / 3);
}
- if (!(player_ptr->inventory_list[INVEN_HEAD].bi_id) && (player_ptr->lev > 4)) {
+ if (!player_ptr->inventory_list[INVEN_HEAD].is_valid() && (player_ptr->lev > 4)) {
ac += (player_ptr->lev - 2) / 3;
}
- if (!(player_ptr->inventory_list[INVEN_ARMS].bi_id)) {
+ if (!player_ptr->inventory_list[INVEN_ARMS].is_valid()) {
ac += (player_ptr->lev / 2);
}
- if (!(player_ptr->inventory_list[INVEN_FEET].bi_id)) {
+ if (!player_ptr->inventory_list[INVEN_FEET].is_valid()) {
ac += (player_ptr->lev / 3);
}
}
for (int i = INVEN_MAIN_HAND; i <= INVEN_FEET; i++) {
auto *o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
if (!o_ptr->is_protector()) {
int penalty = 0;
if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
- auto flags = object_flags(&player_ptr->inventory_list[INVEN_SUB_HAND]);
+ const auto flags = player_ptr->inventory_list[INVEN_SUB_HAND].get_flags();
penalty = ((100 - player_ptr->skill_exp[PlayerSkillKindType::TWO_WEAPON] / 160) - (130 - player_ptr->inventory_list[slot].weight) / 8);
if (set_quick_and_tiny(player_ptr) || set_icing_and_twinkle(player_ptr) || set_anubis_and_chariot(player_ptr)) {
if (has_two_handed_weapons(player_ptr) || (empty_hands(player_ptr, false) == EMPTY_HAND_NONE)) {
return true;
- } else if (any_bits(player_ptr->pet_extra_flags, PF_TWO_HANDS)) {
+ }
+
+ if (any_bits(player_ptr->pet_extra_flags, PF_TWO_HANDS)) {
switch (player_ptr->pclass) {
case PlayerClassType::MONK:
case PlayerClassType::FORCETRAINER:
case PlayerClassType::BERSERKER:
- if ((empty_hands(player_ptr, false) != EMPTY_HAND_NONE) && !has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && !has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
- return true;
- }
-
+ return (empty_hands(player_ptr, false) != EMPTY_HAND_NONE) && !has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && !has_melee_weapon(player_ptr, INVEN_SUB_HAND);
default:
break;
}
if (player_ptr->old_heavy_shoot != heavy_shoot) {
if (heavy_shoot) {
msg_print(_("こんな重い弓を装備しているのは大変だ。", "You have trouble wielding such a heavy bow."));
- } else if (player_ptr->inventory_list[INVEN_BOW].bi_id) {
+ } else if (player_ptr->inventory_list[INVEN_BOW].is_valid()) {
msg_print(_("この弓なら装備していても辛くない。", "You have no trouble wielding your bow."));
} else {
msg_print(_("重い弓を装備からはずして体が楽になった。", "You feel relieved to put down your heavy bow."));
if (player_ptr->is_icky_wield[i]) {
msg_print(_("今の装備はどうも自分にふさわしくない気がする。", "You do not feel comfortable with your weapon."));
if (w_ptr->is_loading_now) {
- chg_virtue(player_ptr, V_FAITH, -1);
+ chg_virtue(player_ptr, Virtue::FAITH, -1);
}
} else if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i)) {
msg_print(_("今の装備は自分にふさわしい気がする。", "You feel comfortable with your weapon."));
if (heavy_armor(player_ptr)) {
msg_print(_("装備が重くてバランスを取れない。", "The weight of your armor disrupts your balance."));
if (w_ptr->is_loading_now) {
- chg_virtue(player_ptr, V_HARMONY, -1);
+ chg_virtue(player_ptr, Virtue::HARMONY, -1);
}
} else {
msg_print(_("バランスがとれるようになった。", "You regain your balance."));
}
}
-static short calc_to_damage(PlayerType *player_ptr, INVENTORY_IDX slot, bool is_real_value)
+static bool is_bare_knuckle(PlayerType *player_ptr)
{
- auto *o_ptr = &player_ptr->inventory_list[slot];
- auto flags = object_flags(o_ptr);
+ auto bare_knuckle = is_martial_arts_mode(player_ptr);
+ bare_knuckle &= empty_hands(player_ptr, false) == (EMPTY_HAND_MAIN | EMPTY_HAND_SUB);
+ return bare_knuckle;
+}
+static short calc_to_damage(PlayerType *player_ptr, INVENTORY_IDX slot, bool is_real_value)
+{
+ const auto *o_ptr = &player_ptr->inventory_list[slot];
player_hand calc_hand = PLAYER_HAND_OTHER;
if (slot == INVEN_MAIN_HAND) {
calc_hand = PLAYER_HAND_MAIN;
damage -= player_stun->get_damage_penalty();
PlayerClass pc(player_ptr);
const auto tval = o_ptr->bi_key.tval();
- if (pc.equals(PlayerClassType::PRIEST) && (flags.has_not(TR_BLESSED)) && ((tval == ItemKindType::SWORD) || (tval == ItemKindType::POLEARM))) {
+ if (pc.equals(PlayerClassType::PRIEST) && (o_ptr->get_flags().has_not(TR_BLESSED)) && ((tval == ItemKindType::SWORD) || (tval == ItemKindType::POLEARM))) {
damage -= 2;
} else if (pc.equals(PlayerClassType::BERSERKER)) {
damage += player_ptr->lev / 6;
int bonus_to_d = 0;
o_ptr = &player_ptr->inventory_list[i];
const auto has_melee = has_melee_weapon(player_ptr, i);
- if ((o_ptr->bi_id == 0) || (o_ptr->bi_key.tval() == ItemKindType::CAPTURE) || ((i == INVEN_MAIN_HAND) && has_melee) || ((i == INVEN_SUB_HAND) && has_melee) || (i == INVEN_BOW)) {
+ if (!o_ptr->is_valid() || (o_ptr->bi_key.tval() == ItemKindType::CAPTURE)) {
+ continue;
+ }
+
+ if (((i == INVEN_MAIN_HAND) && has_melee) || ((i == INVEN_SUB_HAND) && has_melee) || (i == INVEN_BOW)) {
continue;
}
}
if (main_attack_hand(player_ptr) == calc_hand) {
- if ((is_martial_arts_mode(player_ptr) && empty_hands(player_ptr, false) == (EMPTY_HAND_MAIN | EMPTY_HAND_SUB)) || !has_disable_two_handed_bonus(player_ptr, calc_hand)) {
+ if (is_bare_knuckle(player_ptr) || !has_disable_two_handed_bonus(player_ptr, calc_hand)) {
int bonus_to_d = 0;
bonus_to_d = ((int)(adj_str_td[player_ptr->stat_index[A_STR]]) - 128) / 2;
damage += std::max<int>(bonus_to_d, 1);
break;
}
- if ((is_martial_arts_mode(player_ptr) && empty_hands(player_ptr, false) == (EMPTY_HAND_MAIN | EMPTY_HAND_SUB)) || !has_disable_two_handed_bonus(player_ptr, calc_hand)) {
+ if (is_bare_knuckle(player_ptr) || !has_disable_two_handed_bonus(player_ptr, calc_hand)) {
int bonus_to_h = 0;
bonus_to_h = ((int)(adj_str_th[player_ptr->stat_index[A_STR]]) - 128) + ((int)(adj_dex_th[player_ptr->stat_index[A_DEX]]) - 128);
hit += std::max<int>(bonus_to_h, 1);
/* Bonuses and penalties by weapon */
PlayerClass pc(player_ptr);
if (has_melee_weapon(player_ptr, slot)) {
- auto *o_ptr = &player_ptr->inventory_list[slot];
- auto flags = object_flags(o_ptr);
+ const auto *o_ptr = &player_ptr->inventory_list[slot];
/* Traind bonuses */
const auto tval = o_ptr->bi_key.tval();
- const auto sval = o_ptr->bi_key.sval().value();
+ const auto sval = *o_ptr->bi_key.sval();
hit += (player_ptr->weapon_exp[tval][sval] - PlayerSkill::weapon_exp_at(PlayerSkillRank::BEGINNER)) / 200;
/* Weight penalty */
}
/* Riding bonus and penalty */
+ const auto flags = o_ptr->get_flags();
if (player_ptr->riding > 0) {
if (o_ptr->is_lance()) {
hit += 15;
/* Ignore empty hands, handed weapons, bows and capture balls */
const auto has_melee = has_melee_weapon(player_ptr, i);
- if (!o_ptr->bi_id || o_ptr->bi_key.tval() == ItemKindType::CAPTURE || (i == INVEN_MAIN_HAND && has_melee) || (i == INVEN_SUB_HAND && has_melee) || i == INVEN_BOW) {
+ if (!o_ptr->is_valid() || o_ptr->bi_key.tval() == ItemKindType::CAPTURE) {
+ continue;
+ }
+
+ if (((i == INVEN_MAIN_HAND) && has_melee) || ((i == INVEN_SUB_HAND) && has_melee) || (i == INVEN_BOW)) {
continue;
}
{
ItemEntity *o_ptr;
o_ptr = &player_ptr->inventory_list[INVEN_BOW];
- if (o_ptr->bi_id) {
+ if (o_ptr->is_valid()) {
if (o_ptr->curse_flags.has(CurseTraitType::LOW_MELEE)) {
if (o_ptr->curse_flags.has(CurseTraitType::HEAVY_CURSE)) {
pow -= 15;
pow += 2 * (calc_bow_weight_limit(player_ptr) - o_ptr->weight / 10);
}
- if (o_ptr->bi_id) {
- if (o_ptr->bi_id && !is_heavy_shoot(player_ptr, &player_ptr->inventory_list[INVEN_BOW])) {
+ if (o_ptr->is_valid()) {
+ if (!is_heavy_shoot(player_ptr, &player_ptr->inventory_list[INVEN_BOW])) {
if (PlayerClass(player_ptr).equals(PlayerClassType::SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT)) {
pow += (10 + (player_ptr->lev / 5));
}
int bonus_to_h;
o_ptr = &player_ptr->inventory_list[i];
const auto has_melee = has_melee_weapon(player_ptr, i);
- if ((o_ptr->bi_id == 0) || (o_ptr->bi_key.tval() == ItemKindType::CAPTURE) || ((i == INVEN_MAIN_HAND) && has_melee) || ((i == INVEN_SUB_HAND) && has_melee) || i == INVEN_BOW) {
+ if (!o_ptr->is_valid() || (o_ptr->bi_key.tval() == ItemKindType::CAPTURE)) {
+ continue;
+ }
+
+ if (((i == INVEN_MAIN_HAND) && has_melee) || ((i == INVEN_SUB_HAND) && has_melee) || (i == INVEN_BOW)) {
continue;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
o_ptr = &player_ptr->inventory_list[i];
- if (!o_ptr->bi_id) {
+ if (!o_ptr->is_valid()) {
continue;
}
*/
void update_creature(PlayerType *player_ptr)
{
- if (!player_ptr->update) {
+ auto &rfu = RedrawingFlagsUpdater::get_instance();
+ if (!rfu.any_stats()) {
return;
}
auto *floor_ptr = player_ptr->current_floor_ptr;
- if (any_bits(player_ptr->update, (PU_AUTODESTROY))) {
- reset_bits(player_ptr->update, PU_AUTODESTROY);
+ if (rfu.has(StatusRecalculatingFlag::AUTO_DESTRUCTION)) {
+ rfu.reset_flag(StatusRecalculatingFlag::AUTO_DESTRUCTION);
autopick_delayed_alter(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_COMBINE))) {
- reset_bits(player_ptr->update, PU_COMBINE);
+ if (rfu.has(StatusRecalculatingFlag::COMBINATION)) {
+ rfu.reset_flag(StatusRecalculatingFlag::COMBINATION);
combine_pack(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_REORDER))) {
- reset_bits(player_ptr->update, PU_REORDER);
+ if (rfu.has(StatusRecalculatingFlag::REORDER)) {
+ rfu.reset_flag(StatusRecalculatingFlag::REORDER);
reorder_pack(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_BONUS))) {
- reset_bits(player_ptr->update, PU_BONUS);
+ if (rfu.has(StatusRecalculatingFlag::BONUS)) {
+ rfu.reset_flag(StatusRecalculatingFlag::BONUS);
PlayerAlignment(player_ptr).update_alignment();
PlayerSkill ps(player_ptr);
ps.apply_special_weapon_skill_max_values();
update_bonuses(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_TORCH))) {
- reset_bits(player_ptr->update, PU_TORCH);
+ if (rfu.has(StatusRecalculatingFlag::TORCH)) {
+ rfu.reset_flag(StatusRecalculatingFlag::TORCH);
update_lite_radius(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_HP))) {
- reset_bits(player_ptr->update, PU_HP);
+ if (rfu.has(StatusRecalculatingFlag::HP)) {
+ rfu.reset_flag(StatusRecalculatingFlag::HP);
update_max_hitpoints(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_MANA))) {
- reset_bits(player_ptr->update, PU_MANA);
+ if (rfu.has(StatusRecalculatingFlag::MP)) {
+ rfu.reset_flag(StatusRecalculatingFlag::MP);
update_max_mana(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_SPELLS))) {
- reset_bits(player_ptr->update, PU_SPELLS);
+ if (rfu.has(StatusRecalculatingFlag::SPELLS)) {
+ rfu.reset_flag(StatusRecalculatingFlag::SPELLS);
update_num_of_spells(player_ptr);
}
- if (!w_ptr->character_generated) {
- return;
- }
- if (w_ptr->character_icky_depth > 0) {
+ if (!w_ptr->character_generated || (w_ptr->character_icky_depth > 0)) {
return;
}
- if (any_bits(player_ptr->update, (PU_UN_LITE))) {
- reset_bits(player_ptr->update, PU_UN_LITE);
+
+ if (rfu.has(StatusRecalculatingFlag::UN_LITE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::UN_LITE);
forget_lite(floor_ptr);
}
- if (any_bits(player_ptr->update, (PU_UN_VIEW))) {
- reset_bits(player_ptr->update, PU_UN_VIEW);
+ if (rfu.has(StatusRecalculatingFlag::UN_VIEW)) {
+ rfu.reset_flag(StatusRecalculatingFlag::UN_VIEW);
forget_view(floor_ptr);
}
- if (any_bits(player_ptr->update, (PU_VIEW))) {
- reset_bits(player_ptr->update, PU_VIEW);
+ if (rfu.has(StatusRecalculatingFlag::VIEW)) {
+ rfu.reset_flag(StatusRecalculatingFlag::VIEW);
update_view(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_LITE))) {
- reset_bits(player_ptr->update, PU_LITE);
+ if (rfu.has(StatusRecalculatingFlag::LITE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::LITE);
update_lite(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_FLOW))) {
- reset_bits(player_ptr->update, PU_FLOW);
+ if (rfu.has(StatusRecalculatingFlag::FLOW)) {
+ rfu.reset_flag(StatusRecalculatingFlag::FLOW);
update_flow(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_DISTANCE))) {
- reset_bits(player_ptr->update, PU_DISTANCE);
-
+ if (rfu.has(StatusRecalculatingFlag::DISTANCE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::DISTANCE);
update_monsters(player_ptr, true);
}
- if (any_bits(player_ptr->update, (PU_MON_LITE))) {
- reset_bits(player_ptr->update, PU_MON_LITE);
+ if (rfu.has(StatusRecalculatingFlag::MONSTER_LITE)) {
+ rfu.reset_flag(StatusRecalculatingFlag::MONSTER_LITE);
update_mon_lite(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_DELAY_VIS))) {
- reset_bits(player_ptr->update, PU_DELAY_VIS);
+ if (rfu.has(StatusRecalculatingFlag::DELAY_VISIBILITY)) {
+ rfu.reset_flag(StatusRecalculatingFlag::DELAY_VISIBILITY);
delayed_visual_update(player_ptr);
}
- if (any_bits(player_ptr->update, (PU_MONSTERS))) {
- reset_bits(player_ptr->update, PU_MONSTERS);
+ if (rfu.has(StatusRecalculatingFlag::MONSTER_STATUSES)) {
+ rfu.reset_flag(StatusRecalculatingFlag::MONSTER_STATUSES);
update_monsters(player_ptr, false);
}
}
ItemEntity *o_ptr;
for (int i = 0; i < INVEN_PACK; i++) {
o_ptr = &player_ptr->inventory_list[i];
- if (o_ptr->bi_id && check_book_realm(player_ptr, o_ptr->bi_key)) {
+ if (o_ptr->is_valid() && check_book_realm(player_ptr, o_ptr->bi_key)) {
return false;
}
}
auto *floor_ptr = player_ptr->current_floor_ptr;
for (const auto this_o_idx : floor_ptr->grid_array[player_ptr->y][player_ptr->x].o_idx_list) {
o_ptr = &floor_ptr->o_list[this_o_idx];
- if (o_ptr->bi_id && o_ptr->marked.has(OmType::FOUND) && check_book_realm(player_ptr, o_ptr->bi_key)) {
+ if (o_ptr->is_valid() && o_ptr->marked.has(OmType::FOUND) && check_book_realm(player_ptr, o_ptr->bi_key)) {
return false;
}
}
void wreck_the_pattern(PlayerType *player_ptr)
{
auto *floor_ptr = player_ptr->current_floor_ptr;
- int pattern_type = terrains_info[floor_ptr->grid_array[player_ptr->y][player_ptr->x].feat].subtype;
- if (pattern_type == PATTERN_TILE_WRECKED) {
+ const auto p_pos = player_ptr->get_position();
+ const auto &terrain = floor_ptr->get_grid(p_pos).get_terrain();
+ if (terrain.subtype == PATTERN_TILE_WRECKED) {
return;
}
take_hit(player_ptr, DAMAGE_NOESCAPE, damroll(10, 8), _("パターン損壊", "corrupting the Pattern"));
}
- int to_ruin = randint1(45) + 35;
+ auto to_ruin = randint1(45) + 35;
while (to_ruin--) {
- POSITION r_y, r_x;
- scatter(player_ptr, &r_y, &r_x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);
-
- if (pattern_tile(floor_ptr, r_y, r_x) && (terrains_info[floor_ptr->grid_array[r_y][r_x].feat].subtype != PATTERN_TILE_WRECKED)) {
- cave_set_feat(player_ptr, r_y, r_x, feat_pattern_corrupted);
+ int y;
+ int x;
+ scatter(player_ptr, &y, &x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);
+ const Pos2D pos(y, x);
+ if (pattern_tile(floor_ptr, pos.y, pos.x) && (floor_ptr->get_grid(pos).get_terrain().subtype != PATTERN_TILE_WRECKED)) {
+ cave_set_feat(player_ptr, pos.y, pos.x, feat_pattern_corrupted);
}
}
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;
+ static constexpr auto flags_srf = {
+ StatusRecalculatingFlag::BONUS,
+ StatusRecalculatingFlag::HP,
+ StatusRecalculatingFlag::MP,
+ StatusRecalculatingFlag::SPELLS,
+ };
while ((player_ptr->lev > 1) && (player_ptr->exp < ((android ? player_exp_a : player_exp)[player_ptr->lev - 2] * player_ptr->expfact / 100L))) {
player_ptr->lev--;
- set_bits(player_ptr->update, PU_BONUS | PU_HP | PU_MANA | PU_SPELLS);
- set_bits(player_ptr->redraw, PR_LEV | PR_TITLE);
- set_bits(player_ptr->window_flags, PW_PLAYER);
+ rfu.set_flags(flags_srf);
+ static constexpr auto flags_mwrf = {
+ MainWindowRedrawingFlag::LEVEL,
+ MainWindowRedrawingFlag::TITLE,
+ };
+ rfu.set_flags(flags_mwrf);
+ rfu.set_flag(SubWindowRedrawingFlag::PLAYER);
handle_stuff(player_ptr);
}
}
level_inc_stat = true;
- exe_write_diary(player_ptr, DIARY_LEVELUP, player_ptr->lev, nullptr);
+ exe_write_diary(player_ptr, DiaryKind::LEVELUP, player_ptr->lev);
}
sound(SOUND_LEVEL);
msg_format(_("レベル %d にようこそ。", "Welcome to level %d."), player_ptr->lev);
- set_bits(player_ptr->update, (PU_BONUS | PU_HP | PU_MANA | PU_SPELLS));
- set_bits(player_ptr->redraw, (PR_LEV | PR_TITLE | PR_EXP));
- set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL | PW_INVEN));
+ rfu.set_flags(flags_srf);
+ const auto flags_mwrf_levelup = {
+ MainWindowRedrawingFlag::LEVEL,
+ MainWindowRedrawingFlag::TITLE,
+ MainWindowRedrawingFlag::EXP,
+ };
+ rfu.set_flags(flags_mwrf_levelup);
+ const auto &flags_swrf_levelup = {
+ SubWindowRedrawingFlag::PLAYER,
+ SubWindowRedrawingFlag::SPELL,
+ SubWindowRedrawingFlag::INVENTORY,
+ };
+ rfu.set_flags(flags_swrf_levelup);
player_ptr->level_up_message = true;
handle_stuff(player_ptr);
prt("", n + 2, 14);
}
}
- if (get_check(_("よろしいですか？", "Are you sure? "))) {
+ if (input_check(_("よろしいですか？", "Are you sure? "))) {
break;
}
}
level_reward = false;
}
- set_bits(player_ptr->update, PU_BONUS | PU_HP | PU_MANA | PU_SPELLS);
- set_bits(player_ptr->redraw, (PR_LEV | PR_TITLE));
- set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
+ rfu.set_flags(flags_srf);
+ static constexpr auto flags_mwrf = {
+ MainWindowRedrawingFlag::LEVEL,
+ MainWindowRedrawingFlag::TITLE,
+ };
+ rfu.set_flags(flags_mwrf);
+ static constexpr auto flags_swrf = {
+ SubWindowRedrawingFlag::PLAYER,
+ SubWindowRedrawingFlag::SPELL,
+ };
+ rfu.set_flags(flags_swrf);
handle_stuff(player_ptr);
}
bool is_tim_esp(PlayerType *player_ptr)
{
- auto sniper_data = PlayerClass(player_ptr).get_specific_data<sniper_data_type>();
+ auto sniper_data = PlayerClass(player_ptr).get_specific_data<SniperData>();
auto sniper_concent = sniper_data ? sniper_data->concent : 0;
return player_ptr->tim_esp || music_singing(player_ptr, MUSIC_MIND) || (sniper_concent >= CONCENT_TELE_THRESHOLD);
}
bool is_time_limit_esp(PlayerType *player_ptr)
{
- auto sniper_data = PlayerClass(player_ptr).get_specific_data<sniper_data_type>();
+ auto sniper_data = PlayerClass(player_ptr).get_specific_data<SniperData>();
auto sniper_concent = sniper_data ? sniper_data->concent : 0;
return player_ptr->tim_esp || music_singing(player_ptr, MUSIC_MIND) || (sniper_concent >= CONCENT_TELE_THRESHOLD);
}
OSDN Git Service
