src/player/player-status.cpp

   1 #include "player/player-status.h"
   2 #include "artifact/fixed-art-types.h"
   3 #include "autopick/autopick-reader-writer.h"
   4 #include "autopick/autopick.h"
   5 #include "avatar/avatar.h"
   6 #include "cmd-action/cmd-pet.h"
   7 #include "cmd-action/cmd-spell.h"
   8 #include "cmd-io/cmd-dump.h"
   9 #include "cmd-item/cmd-magiceat.h"
  10 #include "combat/attack-power-table.h"
  11 #include "core/asking-player.h"
  12 #include "core/player-redraw-types.h"
  13 #include "core/player-update-types.h"
  14 #include "core/stuff-handler.h"
  15 #include "core/window-redrawer.h"
  16 #include "dungeon/dungeon-flag-types.h"
  17 #include "dungeon/dungeon.h"
  18 #include "effect/effect-characteristics.h"
  19 #include "floor/cave.h"
  20 #include "floor/floor-events.h"
  21 #include "floor/floor-leaver.h"
  22 #include "floor/floor-save.h"
  23 #include "floor/floor-util.h"
  24 #include "game-option/birth-options.h"
  25 #include "grid/feature.h"
  26 #include "grid/grid.h"
  27 #include "inventory/inventory-object.h"
  28 #include "io/input-key-acceptor.h"
  29 #include "io/write-diary.h"
  30 #include "main/sound-definitions-table.h"
  31 #include "main/sound-of-music.h"
  32 #include "market/arena-info-table.h"
  33 #include "mind/mind-force-trainer.h"
  34 #include "mind/mind-ninja.h"
  35 #include "monster-floor/monster-lite.h"
  36 #include "monster-floor/monster-remover.h"
  37 #include "monster-race/monster-race-hook.h"
  38 #include "monster-race/monster-race.h"
  39 #include "monster-race/race-flags1.h"
  40 #include "monster-race/race-flags2.h"
  41 #include "monster-race/race-flags7.h"
  42 #include "monster/monster-update.h"
  43 #include "monster/smart-learn-types.h"
  44 #include "mutation/mutation-calculator.h"
  45 #include "mutation/mutation-flag-types.h"
  46 #include "mutation/mutation-investor-remover.h"
  47 #include "object-enchant/object-ego.h"
  48 #include "object-enchant/special-object-flags.h"
  49 #include "object-enchant/tr-types.h"
  50 #include "object-enchant/trc-types.h"
  51 #include "object-hook/hook-armor.h"
  52 #include "object/object-flags.h"
  53 #include "object/object-info.h"
  54 #include "object/object-mark-types.h"
  55 #include "perception/object-perception.h"
  56 #include "pet/pet-util.h"
  57 #include "player-base/player-class.h"
  58 #include "player-base/player-race.h"
  59 #include "player-info/alignment.h"
  60 #include "player-info/class-info.h"
  61 #include "player-info/equipment-info.h"
  62 #include "player-info/mimic-info-table.h"
  63 #include "player-info/monk-data-type.h"
  64 #include "player-info/samurai-data-type.h"
  65 #include "player-info/sniper-data-type.h"
  66 #include "player-status/player-basic-statistics.h"
  67 #include "player-status/player-hand-types.h"
  68 #include "player-status/player-infravision.h"
  69 #include "player-status/player-speed.h"
  70 #include "player-status/player-stealth.h"
  71 #include "player/attack-defense-types.h"
  72 #include "player/digestion-processor.h"
  73 #include "player/patron.h"
  74 #include "player/player-damage.h"
  75 #include "player/player-move.h"
  76 #include "player/player-personality-types.h"
  77 #include "player/player-personality.h"
  78 #include "player/player-skill.h"
  79 #include "player/player-status-flags.h"
  80 #include "player/player-status-table.h"
  81 #include "player/player-view.h"
  82 #include "player/race-info-table.h"
  83 #include "player/special-defense-types.h"
  84 #include "realm/realm-hex-numbers.h"
  85 #include "realm/realm-names-table.h"
  86 #include "realm/realm-song-numbers.h"
  87 #include "specific-object/bow.h"
  88 #include "specific-object/torch.h"
  89 #include "spell-realm/spells-hex.h"
  90 #include "spell-realm/spells-song.h"
  91 #include "spell/range-calc.h"
  92 #include "spell/spells-describer.h"
  93 #include "spell/spells-execution.h"
  94 #include "spell/spells-status.h"
  95 #include "spell/technic-info-table.h"
  96 #include "status/action-setter.h"
  97 #include "status/base-status.h"
  98 #include "sv-definition/sv-lite-types.h"
  99 #include "sv-definition/sv-weapon-types.h"
 100 #include "system/floor-type-definition.h"
 101 #include "system/grid-type-definition.h"
 102 #include "system/monster-race-definition.h"
 103 #include "system/monster-type-definition.h"
 104 #include "system/object-type-definition.h"
 105 #include "system/player-type-definition.h"
 106 #include "term/screen-processor.h"
 107 #include "timed-effect/player-stun.h"
 108 #include "timed-effect/timed-effects.h"
 109 #include "util/bit-flags-calculator.h"
 110 #include "util/enum-converter.h"
 111 #include "util/quarks.h"
 112 #include "util/string-processor.h"
 113 #include "view/display-messages.h"
 114 #include "world/world.h"
 115
 116 static const int extra_magic_glove_reduce_mana = 1;
 117
 118 static bool is_martial_arts_mode(player_type *player_ptr);
 119
 120 static ACTION_SKILL_POWER calc_disarming(player_type *player_ptr);
 121 static ACTION_SKILL_POWER calc_device_ability(player_type *player_ptr);
 122 static ACTION_SKILL_POWER calc_saving_throw(player_type *player_ptr);
 123 static ACTION_SKILL_POWER calc_search(player_type *player_ptr);
 124 static ACTION_SKILL_POWER calc_search_freq(player_type *player_ptr);
 125 static ACTION_SKILL_POWER calc_to_hit_melee(player_type *player_ptr);
 126 static ACTION_SKILL_POWER calc_to_hit_shoot(player_type *player_ptr);
 127 static ACTION_SKILL_POWER calc_to_hit_throw(player_type *player_ptr);
 128 static ACTION_SKILL_POWER calc_skill_dig(player_type *player_ptr);
 129 static bool is_heavy_wield(player_type *player_ptr, int i);
 130 static int16_t calc_num_blow(player_type *player_ptr, int i);
 131 static int16_t calc_to_magic_chance(player_type *player_ptr);
 132 static ARMOUR_CLASS calc_base_ac(player_type *player_ptr);
 133 static ARMOUR_CLASS calc_to_ac(player_type *player_ptr, bool is_real_value);
 134 static int16_t calc_double_weapon_penalty(player_type *player_ptr, INVENTORY_IDX slot);
 135 static bool is_riding_two_hands(player_type *player_ptr);
 136 static int16_t calc_riding_bow_penalty(player_type *player_ptr);
 137 static void put_equipment_warning(player_type *player_ptr);
 138
 139 static short calc_to_damage(player_type *player_ptr, INVENTORY_IDX slot, bool is_real_value);
 140 static int16_t calc_to_hit(player_type *player_ptr, INVENTORY_IDX slot, bool is_real_value);
 141
 142 static int16_t calc_to_hit_bow(player_type *player_ptr, bool is_real_value);
 143
 144 static int16_t calc_to_damage_misc(player_type *player_ptr);
 145 static int16_t calc_to_hit_misc(player_type *player_ptr);
 146
 147 static DICE_NUMBER calc_to_weapon_dice_num(player_type *player_ptr, INVENTORY_IDX slot);
 148 static player_hand main_attack_hand(player_type *player_ptr);
 149
 150 /*** Player information ***/
 151
 152 /*!
 153  * @brief 遅延描画更新 / Delayed visual update
 154  * @details update_view(), update_lite(), update_mon_lite() においてのみ更新すること / Only used if update_view(), update_lite() or update_mon_lite() was called
 155  * @param player_ptr 主観となるプレイヤー構造体参照ポインタ
 156  * @todo 将来独自インターフェース実装にはz-term系に追い出すべきか？
 157  */
 158 static void delayed_visual_update(player_type *player_ptr)
 159 {
 160     floor_type *floor_ptr = player_ptr->current_floor_ptr;
 161     for (int i = 0; i < floor_ptr->redraw_n; i++) {
 162         POSITION y = floor_ptr->redraw_y[i];
 163         POSITION x = floor_ptr->redraw_x[i];
 164         grid_type *g_ptr;
 165         g_ptr = &floor_ptr->grid_array[y][x];
 166         if (none_bits(g_ptr->info, CAVE_REDRAW))
 167             continue;
 168
 169         if (any_bits(g_ptr->info, CAVE_NOTE))
 170             note_spot(player_ptr, y, x);
 171
 172         lite_spot(player_ptr, y, x);
 173         if (g_ptr->m_idx)
 174             update_monster(player_ptr, g_ptr->m_idx, false);
 175
 176         reset_bits(g_ptr->info, (CAVE_NOTE | CAVE_REDRAW));
 177     }
 178
 179     floor_ptr->redraw_n = 0;
 180 }
 181
 182 /*!
 183  * @brief 射撃武器がプレイヤーにとって重すぎるかどうかの判定 /
 184  * @param o_ptr 判定する射撃武器のアイテム情報参照ポインタ
 185  * @return 重すぎるならばTRUE
 186  */
 187 static bool is_heavy_shoot(player_type *player_ptr, object_type *o_ptr)
 188 {
 189     return (calc_bow_weight_limit(player_ptr) < o_ptr->weight / 10);
 190 }
 191
 192 /*!
 193  * @brief 所持品総重量を計算する
 194  * @param player_ptr プレイヤーへの参照ポインタ
 195  * @return 総重量
 196  */
 197 WEIGHT calc_inventory_weight(player_type *player_ptr)
 198 {
 199     WEIGHT weight = 0;
 200
 201     object_type *o_ptr;
 202     for (int i = 0; i < INVEN_TOTAL; i++) {
 203         o_ptr = &player_ptr->inventory_list[i];
 204         if (!o_ptr->k_idx)
 205             continue;
 206         weight += o_ptr->weight * o_ptr->number;
 207     }
 208     return weight;
 209 }
 210
 211 static void update_ability_scores(player_type *player_ptr)
 212 {
 213     PlayerStrength player_str(player_ptr);
 214     PlayerIntelligence player_int(player_ptr);
 215     PlayerWisdom player_wis(player_ptr);
 216     PlayerDexterity player_dex(player_ptr);
 217     PlayerConstitution player_con(player_ptr);
 218     PlayerCharisma player_chr(player_ptr);
 219     PlayerBasicStatistics *player_stats[] = { &player_str, &player_int, &player_wis, &player_dex, &player_con, &player_chr };
 220     for (auto i = 0; i < A_MAX; ++i) {
 221         player_ptr->stat_add[i] = player_stats[i]->modification_value();
 222         player_stats[i]->update_value();
 223     }
 224 }
 225
 226 /*!
 227  * @brief プレイヤーの全ステータスを更新する /
 228  * Calculate the players current "state", taking into account
 229  * not only race/class intrinsics, but also objects being worn
 230  * and temporary spell effects.
 231  * @details
 232  * <pre>
 233  * See also update_max_mana() and update_max_hitpoints().
 234  *
 235  * Take note of the new "speed code", in particular, a very strong
 236  * player will start slowing down as soon as he reaches 150 pounds,
 237  * but not until he reaches 450 pounds will he be half as fast as
 238  * a normal kobold.  This both hurts and helps the player, hurts
 239  * because in the old days a player could just avoid 300 pounds,
 240  * and helps because now carrying 300 pounds is not very painful.
 241  *
 242  * The "weapon" and "bow" do *not* add to the bonuses to hit or to
 243  * damage, since that would affect non-combat things.  These values
 244  * are actually added in later, at the appropriate place.
 245  *
 246  * This function induces various "status" messages.
 247  * </pre>
 248  * @todo ここで計算していた各値は一部の状態変化メッセージ処理を除き、今後必要な時に適示計算する形に移行するためほぼすべて削られる。
 249  */
 250 static void update_bonuses(player_type *player_ptr)
 251 {
 252     auto empty_hands_status = empty_hands(player_ptr, true);
 253     object_type *o_ptr;
 254
 255     /* Save the old vision stuff */
 256     BIT_FLAGS old_telepathy = player_ptr->telepathy;
 257     BIT_FLAGS old_esp_animal = player_ptr->esp_animal;
 258     BIT_FLAGS old_esp_undead = player_ptr->esp_undead;
 259     BIT_FLAGS old_esp_demon = player_ptr->esp_demon;
 260     BIT_FLAGS old_esp_orc = player_ptr->esp_orc;
 261     BIT_FLAGS old_esp_troll = player_ptr->esp_troll;
 262     BIT_FLAGS old_esp_giant = player_ptr->esp_giant;
 263     BIT_FLAGS old_esp_dragon = player_ptr->esp_dragon;
 264     BIT_FLAGS old_esp_human = player_ptr->esp_human;
 265     BIT_FLAGS old_esp_evil = player_ptr->esp_evil;
 266     BIT_FLAGS old_esp_good = player_ptr->esp_good;
 267     BIT_FLAGS old_esp_nonliving = player_ptr->esp_nonliving;
 268     BIT_FLAGS old_esp_unique = player_ptr->esp_unique;
 269     BIT_FLAGS old_see_inv = player_ptr->see_inv;
 270     BIT_FLAGS old_mighty_throw = player_ptr->mighty_throw;
 271     int16_t old_speed = player_ptr->pspeed;
 272
 273     ARMOUR_CLASS old_dis_ac = player_ptr->dis_ac;
 274     ARMOUR_CLASS old_dis_to_a = player_ptr->dis_to_a;
 275
 276     player_ptr->xtra_might = has_xtra_might(player_ptr);
 277     player_ptr->esp_evil = has_esp_evil(player_ptr);
 278     player_ptr->esp_animal = has_esp_animal(player_ptr);
 279     player_ptr->esp_undead = has_esp_undead(player_ptr);
 280     player_ptr->esp_demon = has_esp_demon(player_ptr);
 281     player_ptr->esp_orc = has_esp_orc(player_ptr);
 282     player_ptr->esp_troll = has_esp_troll(player_ptr);
 283     player_ptr->esp_giant = has_esp_giant(player_ptr);
 284     player_ptr->esp_dragon = has_esp_dragon(player_ptr);
 285     player_ptr->esp_human = has_esp_human(player_ptr);
 286     player_ptr->esp_good = has_esp_good(player_ptr);
 287     player_ptr->esp_nonliving = has_esp_nonliving(player_ptr);
 288     player_ptr->esp_unique = has_esp_unique(player_ptr);
 289     player_ptr->telepathy = has_esp_telepathy(player_ptr);
 290     player_ptr->bless_blade = has_bless_blade(player_ptr);
 291     player_ptr->easy_2weapon = has_easy2_weapon(player_ptr);
 292     player_ptr->down_saving = has_down_saving(player_ptr);
 293     player_ptr->yoiyami = has_no_ac(player_ptr);
 294     player_ptr->mighty_throw = has_mighty_throw(player_ptr);
 295     player_ptr->dec_mana = has_dec_mana(player_ptr);
 296     player_ptr->see_nocto = has_see_nocto(player_ptr);
 297     player_ptr->warning = has_warning(player_ptr);
 298     player_ptr->anti_magic = has_anti_magic(player_ptr);
 299     player_ptr->anti_tele = has_anti_tele(player_ptr);
 300     player_ptr->easy_spell = has_easy_spell(player_ptr);
 301     player_ptr->heavy_spell = has_heavy_spell(player_ptr);
 302     player_ptr->hold_exp = has_hold_exp(player_ptr);
 303     player_ptr->see_inv = has_see_inv(player_ptr);
 304     player_ptr->free_act = has_free_act(player_ptr);
 305     player_ptr->levitation = has_levitation(player_ptr);
 306     player_ptr->can_swim = has_can_swim(player_ptr);
 307     player_ptr->slow_digest = has_slow_digest(player_ptr);
 308     player_ptr->regenerate = has_regenerate(player_ptr);
 309     update_curses(player_ptr);
 310     player_ptr->impact = has_impact(player_ptr);
 311     player_ptr->earthquake = has_earthquake(player_ptr);
 312     update_extra_blows(player_ptr);
 313
 314     player_ptr->lite = has_lite(player_ptr);
 315
 316     if (!PlayerClass(player_ptr).monk_stance_is(MonkStance::NONE)) {
 317         if (none_bits(empty_hands_status, EMPTY_HAND_MAIN)) {
 318             set_action(player_ptr, ACTION_NONE);
 319         }
 320     }
 321
 322     update_ability_scores(player_ptr);
 323     o_ptr = &player_ptr->inventory_list[INVEN_BOW];
 324     if (o_ptr->k_idx) {
 325         player_ptr->tval_ammo = bow_tval_ammo(o_ptr);
 326         player_ptr->num_fire = calc_num_fire(player_ptr, o_ptr);
 327     }
 328
 329     for (int i = 0; i < 2; i++) {
 330         player_ptr->is_icky_wield[i] = is_wielding_icky_weapon(player_ptr, i);
 331         player_ptr->is_icky_riding_wield[i] = is_wielding_icky_riding_weapon(player_ptr, i);
 332         player_ptr->heavy_wield[i] = is_heavy_wield(player_ptr, i);
 333         player_ptr->num_blow[i] = calc_num_blow(player_ptr, i);
 334         player_ptr->to_dd[i] = calc_to_weapon_dice_num(player_ptr, INVEN_MAIN_HAND + i);
 335         player_ptr->to_ds[i] = 0;
 336     }
 337
 338     player_ptr->pspeed = PlayerSpeed(player_ptr).get_value();
 339     player_ptr->see_infra = PlayerInfravision(player_ptr).get_value();
 340     player_ptr->skill_stl = PlayerStealth(player_ptr).get_value();
 341     player_ptr->skill_dis = calc_disarming(player_ptr);
 342     player_ptr->skill_dev = calc_device_ability(player_ptr);
 343     player_ptr->skill_sav = calc_saving_throw(player_ptr);
 344     player_ptr->skill_srh = calc_search(player_ptr);
 345     player_ptr->skill_fos = calc_search_freq(player_ptr);
 346     player_ptr->skill_thn = calc_to_hit_melee(player_ptr);
 347     player_ptr->skill_thb = calc_to_hit_shoot(player_ptr);
 348     player_ptr->skill_tht = calc_to_hit_throw(player_ptr);
 349     player_ptr->riding_ryoute = is_riding_two_hands(player_ptr);
 350     player_ptr->to_d[0] = calc_to_damage(player_ptr, INVEN_MAIN_HAND, true);
 351     player_ptr->to_d[1] = calc_to_damage(player_ptr, INVEN_SUB_HAND, true);
 352     player_ptr->dis_to_d[0] = calc_to_damage(player_ptr, INVEN_MAIN_HAND, false);
 353     player_ptr->dis_to_d[1] = calc_to_damage(player_ptr, INVEN_SUB_HAND, false);
 354     player_ptr->to_h[0] = calc_to_hit(player_ptr, INVEN_MAIN_HAND, true);
 355     player_ptr->to_h[1] = calc_to_hit(player_ptr, INVEN_SUB_HAND, true);
 356     player_ptr->dis_to_h[0] = calc_to_hit(player_ptr, INVEN_MAIN_HAND, false);
 357     player_ptr->dis_to_h[1] = calc_to_hit(player_ptr, INVEN_SUB_HAND, false);
 358     player_ptr->to_h_b = calc_to_hit_bow(player_ptr, true);
 359     player_ptr->dis_to_h_b = calc_to_hit_bow(player_ptr, false);
 360     player_ptr->to_d_m = calc_to_damage_misc(player_ptr);
 361     player_ptr->to_h_m = calc_to_hit_misc(player_ptr);
 362     player_ptr->skill_dig = calc_skill_dig(player_ptr);
 363     player_ptr->to_m_chance = calc_to_magic_chance(player_ptr);
 364     player_ptr->ac = calc_base_ac(player_ptr);
 365     player_ptr->to_a = calc_to_ac(player_ptr, true);
 366     player_ptr->dis_ac = calc_base_ac(player_ptr);
 367     player_ptr->dis_to_a = calc_to_ac(player_ptr, false);
 368
 369     if (old_mighty_throw != player_ptr->mighty_throw) {
 370         player_ptr->window_flags |= PW_INVEN;
 371     }
 372
 373     if (player_ptr->telepathy != old_telepathy) {
 374         set_bits(player_ptr->update, PU_MONSTERS);
 375     }
 376
 377     if ((player_ptr->esp_animal != old_esp_animal) || (player_ptr->esp_undead != old_esp_undead) || (player_ptr->esp_demon != old_esp_demon)
 378         || (player_ptr->esp_orc != old_esp_orc) || (player_ptr->esp_troll != old_esp_troll) || (player_ptr->esp_giant != old_esp_giant)
 379         || (player_ptr->esp_dragon != old_esp_dragon) || (player_ptr->esp_human != old_esp_human) || (player_ptr->esp_evil != old_esp_evil)
 380         || (player_ptr->esp_good != old_esp_good) || (player_ptr->esp_nonliving != old_esp_nonliving) || (player_ptr->esp_unique != old_esp_unique)) {
 381         set_bits(player_ptr->update, PU_MONSTERS);
 382     }
 383
 384     if (player_ptr->see_inv != old_see_inv) {
 385         set_bits(player_ptr->update, PU_MONSTERS);
 386     }
 387
 388     if (player_ptr->pspeed != old_speed) {
 389         set_bits(player_ptr->redraw, PR_SPEED);
 390     }
 391
 392     if ((player_ptr->dis_ac != old_dis_ac) || (player_ptr->dis_to_a != old_dis_to_a)) {
 393         set_bits(player_ptr->redraw, PR_ARMOR);
 394         set_bits(player_ptr->window_flags, PW_PLAYER);
 395     }
 396
 397     if (w_ptr->character_xtra)
 398         return;
 399
 400     put_equipment_warning(player_ptr);
 401     check_no_flowed(player_ptr);
 402 }
 403
 404 /*!
 405  * @brief プレイヤーの最大HPを更新する /
 406  * Update the players maximal hit points
 407  * Adjust current hitpoints if necessary
 408  * @details
 409  */
 410 static void update_max_hitpoints(player_type *player_ptr)
 411 {
 412     int bonus = ((int)(adj_con_mhp[player_ptr->stat_index[A_CON]]) - 128) * player_ptr->lev / 4;
 413     int mhp = player_ptr->player_hp[player_ptr->lev - 1];
 414
 415     byte tmp_hitdie;
 416     if (player_ptr->mimic_form) {
 417         if (player_ptr->pclass == PlayerClassType::SORCERER)
 418             tmp_hitdie = mimic_info[player_ptr->mimic_form].r_mhp / 2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
 419         else
 420             tmp_hitdie = mimic_info[player_ptr->mimic_form].r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
 421         mhp = mhp * tmp_hitdie / player_ptr->hitdie;
 422     }
 423
 424     if (player_ptr->pclass == PlayerClassType::SORCERER) {
 425         if (player_ptr->lev < 30)
 426             mhp = (mhp * (45 + player_ptr->lev) / 100);
 427         else
 428             mhp = (mhp * 75 / 100);
 429         bonus = (bonus * 65 / 100);
 430     }
 431
 432     mhp += bonus;
 433
 434     if (player_ptr->pclass == PlayerClassType::BERSERKER) {
 435         mhp = mhp * (110 + (((player_ptr->lev + 40) * (player_ptr->lev + 40) - 1550) / 110)) / 100;
 436     }
 437
 438     if (mhp < player_ptr->lev + 1)
 439         mhp = player_ptr->lev + 1;
 440     if (is_hero(player_ptr))
 441         mhp += 10;
 442     if (is_shero(player_ptr))
 443         mhp += 30;
 444     if (player_ptr->tsuyoshi)
 445         mhp += 50;
 446     if (SpellHex(player_ptr).is_spelling_specific(HEX_XTRA_MIGHT))
 447         mhp += 15;
 448     if (SpellHex(player_ptr).is_spelling_specific(HEX_BUILDING))
 449         mhp += 60;
 450     if (player_ptr->mhp == mhp)
 451         return;
 452
 453     if (player_ptr->chp >= mhp) {
 454         player_ptr->chp = mhp;
 455         player_ptr->chp_frac = 0;
 456     }
 457
 458 #ifdef JP
 459     if (player_ptr->level_up_message && (mhp > player_ptr->mhp)) {
 460         msg_format("最大ヒット・ポイントが %d 増加した！", (mhp - player_ptr->mhp));
 461     }
 462 #endif
 463     player_ptr->mhp = mhp;
 464
 465     player_ptr->redraw |= PR_HP;
 466     player_ptr->window_flags |= PW_PLAYER;
 467 }
 468
 469 /*!
 470  * @brief プレイヤーの現在学習可能な魔法数を計算し、増減に応じて魔法の忘却、再学習を処置する。 /
 471  * Calculate number of spells player should have, and forget,
 472  * or remember, spells until that number is properly reflected.
 473  * @details
 474  * Note that this function induces various "status" messages,
 475  * which must be bypasses until the character is created.
 476  */
 477 static void update_num_of_spells(player_type *player_ptr)
 478 {
 479     if (mp_ptr->spell_book == ItemKindType::NONE)
 480         return;
 481     if (!w_ptr->character_generated)
 482         return;
 483     if (w_ptr->character_xtra)
 484         return;
 485     if ((player_ptr->pclass == PlayerClassType::SORCERER) || (player_ptr->pclass == PlayerClassType::RED_MAGE)) {
 486         player_ptr->new_spells = 0;
 487         return;
 488     }
 489
 490     concptr p = spell_category_name(mp_ptr->spell_book);
 491     int levels = player_ptr->lev - mp_ptr->spell_first + 1;
 492     if (levels < 0)
 493         levels = 0;
 494
 495     int num_allowed = (adj_mag_study[player_ptr->stat_index[mp_ptr->spell_stat]] * levels / 2);
 496     int bonus = 0;
 497     if ((player_ptr->pclass != PlayerClassType::SAMURAI) && (mp_ptr->spell_book != ItemKindType::LIFE_BOOK)) {
 498         bonus = 4;
 499     }
 500
 501     if (player_ptr->pclass == PlayerClassType::SAMURAI) {
 502         num_allowed = 32;
 503     } else if (player_ptr->realm2 == REALM_NONE) {
 504         num_allowed = (num_allowed + 1) / 2;
 505         if (num_allowed > (32 + bonus))
 506             num_allowed = 32 + bonus;
 507     } else if ((player_ptr->pclass == PlayerClassType::MAGE) || (player_ptr->pclass == PlayerClassType::PRIEST)) {
 508         if (num_allowed > (96 + bonus))
 509             num_allowed = 96 + bonus;
 510     } else {
 511         if (num_allowed > (80 + bonus))
 512             num_allowed = 80 + bonus;
 513     }
 514
 515     int num_boukyaku = 0;
 516     for (int j = 0; j < 64; j++) {
 517         if ((j < 32) ? any_bits(player_ptr->spell_forgotten1, (1UL << j)) : any_bits(player_ptr->spell_forgotten2, (1UL << (j - 32)))) {
 518             num_boukyaku++;
 519         }
 520     }
 521
 522     player_ptr->new_spells = num_allowed + player_ptr->add_spells + num_boukyaku - player_ptr->learned_spells;
 523     for (int i = 63; i >= 0; i--) {
 524         if (!player_ptr->spell_learned1 && !player_ptr->spell_learned2)
 525             break;
 526
 527         int j = player_ptr->spell_order[i];
 528         if (j >= 99)
 529             continue;
 530
 531         const magic_type *s_ptr;
 532         if (!is_magic((j < 32) ? player_ptr->realm1 : player_ptr->realm2)) {
 533             if (j < 32)
 534                 s_ptr = &technic_info[player_ptr->realm1 - MIN_TECHNIC][j];
 535             else
 536                 s_ptr = &technic_info[player_ptr->realm2 - MIN_TECHNIC][j % 32];
 537         } else if (j < 32)
 538             s_ptr = &mp_ptr->info[player_ptr->realm1 - 1][j];
 539         else
 540             s_ptr = &mp_ptr->info[player_ptr->realm2 - 1][j % 32];
 541
 542         if (s_ptr->slevel <= player_ptr->lev)
 543             continue;
 544
 545         bool is_spell_learned = (j < 32) ? any_bits(player_ptr->spell_learned1, (1UL << j)) : any_bits(player_ptr->spell_learned2, (1UL << (j - 32)));
 546         if (!is_spell_learned)
 547             continue;
 548
 549         int16_t which;
 550         if (j < 32) {
 551             set_bits(player_ptr->spell_forgotten1, (1UL << j));
 552             which = player_ptr->realm1;
 553         } else {
 554             set_bits(player_ptr->spell_forgotten2, (1UL << (j - 32)));
 555             which = player_ptr->realm2;
 556         }
 557
 558         if (j < 32) {
 559             reset_bits(player_ptr->spell_learned1, (1UL << j));
 560             which = player_ptr->realm1;
 561         } else {
 562             reset_bits(player_ptr->spell_learned2, (1UL << (j - 32)));
 563             which = player_ptr->realm2;
 564         }
 565
 566 #ifdef JP
 567         msg_format("%sの%sを忘れてしまった。", exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME), p);
 568 #else
 569         msg_format("You have forgotten the %s of %s.", p, exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME));
 570 #endif
 571         player_ptr->new_spells++;
 572     }
 573
 574     /* Forget spells if we know too many spells */
 575     for (int i = 63; i >= 0; i--) {
 576         if (player_ptr->new_spells >= 0)
 577             break;
 578         if (!player_ptr->spell_learned1 && !player_ptr->spell_learned2)
 579             break;
 580
 581         int j = player_ptr->spell_order[i];
 582         if (j >= 99)
 583             continue;
 584
 585         bool is_spell_learned = (j < 32) ? any_bits(player_ptr->spell_learned1, (1UL << j)) : any_bits(player_ptr->spell_learned2, (1UL << (j - 32)));
 586         if (!is_spell_learned)
 587             continue;
 588
 589         int16_t which;
 590         if (j < 32) {
 591             set_bits(player_ptr->spell_forgotten1, (1UL << j));
 592             which = player_ptr->realm1;
 593         } else {
 594             set_bits(player_ptr->spell_forgotten2, (1UL << (j - 32)));
 595             which = player_ptr->realm2;
 596         }
 597
 598         if (j < 32) {
 599             reset_bits(player_ptr->spell_learned1, (1UL << j));
 600             which = player_ptr->realm1;
 601         } else {
 602             reset_bits(player_ptr->spell_learned2, (1UL << (j - 32)));
 603             which = player_ptr->realm2;
 604         }
 605
 606 #ifdef JP
 607         msg_format("%sの%sを忘れてしまった。", exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME), p);
 608 #else
 609         msg_format("You have forgotten the %s of %s.", p, exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME));
 610 #endif
 611         player_ptr->new_spells++;
 612     }
 613
 614     /* Check for spells to remember */
 615     for (int i = 0; i < 64; i++) {
 616         if (player_ptr->new_spells <= 0)
 617             break;
 618         if (!player_ptr->spell_forgotten1 && !player_ptr->spell_forgotten2)
 619             break;
 620         int j = player_ptr->spell_order[i];
 621         if (j >= 99)
 622             break;
 623
 624         const magic_type *s_ptr;
 625         if (!is_magic((j < 32) ? player_ptr->realm1 : player_ptr->realm2)) {
 626             if (j < 32)
 627                 s_ptr = &technic_info[player_ptr->realm1 - MIN_TECHNIC][j];
 628             else
 629                 s_ptr = &technic_info[player_ptr->realm2 - MIN_TECHNIC][j % 32];
 630         } else if (j < 32)
 631             s_ptr = &mp_ptr->info[player_ptr->realm1 - 1][j];
 632         else
 633             s_ptr = &mp_ptr->info[player_ptr->realm2 - 1][j % 32];
 634
 635         if (s_ptr->slevel > player_ptr->lev)
 636             continue;
 637
 638         bool is_spell_learned = (j < 32) ? any_bits(player_ptr->spell_forgotten1, (1UL << j)) : any_bits(player_ptr->spell_forgotten2, (1UL << (j - 32)));
 639         if (!is_spell_learned)
 640             continue;
 641
 642         int16_t which;
 643         if (j < 32) {
 644             reset_bits(player_ptr->spell_forgotten1, (1UL << j));
 645             which = player_ptr->realm1;
 646         } else {
 647             reset_bits(player_ptr->spell_forgotten2, (1UL << (j - 32)));
 648             which = player_ptr->realm2;
 649         }
 650
 651         if (j < 32) {
 652             set_bits(player_ptr->spell_learned1, (1UL << j));
 653             which = player_ptr->realm1;
 654         } else {
 655             set_bits(player_ptr->spell_learned2, (1UL << (j - 32)));
 656             which = player_ptr->realm2;
 657         }
 658
 659 #ifdef JP
 660         msg_format("%sの%sを思い出した。", exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME), p);
 661 #else
 662         msg_format("You have remembered the %s of %s.", p, exe_spell(player_ptr, which, j % 32, SpellProcessType::NAME));
 663 #endif
 664         player_ptr->new_spells--;
 665     }
 666
 667     if (player_ptr->realm2 == REALM_NONE) {
 668         int k = 0;
 669         for (int j = 0; j < 32; j++) {
 670             const magic_type *s_ptr;
 671             if (!is_magic(player_ptr->realm1))
 672                 s_ptr = &technic_info[player_ptr->realm1 - MIN_TECHNIC][j];
 673             else
 674                 s_ptr = &mp_ptr->info[player_ptr->realm1 - 1][j];
 675
 676             if (s_ptr->slevel > player_ptr->lev)
 677                 continue;
 678
 679             if (any_bits(player_ptr->spell_learned1, (1UL << j))) {
 680                 continue;
 681             }
 682
 683             k++;
 684         }
 685
 686         if (k > 32)
 687             k = 32;
 688         if ((player_ptr->new_spells > k) && ((mp_ptr->spell_book == ItemKindType::LIFE_BOOK) || (mp_ptr->spell_book == ItemKindType::HISSATSU_BOOK))) {
 689             player_ptr->new_spells = (int16_t)k;
 690         }
 691     }
 692
 693     if (player_ptr->new_spells < 0)
 694         player_ptr->new_spells = 0;
 695
 696     if (player_ptr->old_spells == player_ptr->new_spells)
 697         return;
 698
 699     if (player_ptr->new_spells) {
 700 #ifdef JP
 701         if (player_ptr->new_spells < 10) {
 702             msg_format("あと %d つの%sを学べる。", player_ptr->new_spells, p);
 703         } else {
 704             msg_format("あと %d 個の%sを学べる。", player_ptr->new_spells, p);
 705         }
 706 #else
 707         msg_format("You can learn %d more %s%s.", player_ptr->new_spells, p, (player_ptr->new_spells != 1) ? "s" : "");
 708 #endif
 709     }
 710
 711     player_ptr->old_spells = player_ptr->new_spells;
 712     set_bits(player_ptr->redraw, PR_STUDY);
 713     set_bits(player_ptr->window_flags, PW_OBJECT);
 714 }
 715
 716 /*!
 717  * @brief プレイヤーの最大MPを更新する /
 718  * Update maximum mana.  You do not need to know any spells.
 719  * Note that mana is lowered by heavy (or inappropriate) armor.
 720  * @details
 721  * This function induces status messages.
 722  */
 723 static void update_max_mana(player_type *player_ptr)
 724 {
 725     if ((mp_ptr->spell_book == ItemKindType::NONE) && mp_ptr->spell_first == SPELL_FIRST_NO_SPELL)
 726         return;
 727
 728     int levels;
 729     if ((player_ptr->pclass == PlayerClassType::MINDCRAFTER) || (player_ptr->pclass == PlayerClassType::MIRROR_MASTER) || (player_ptr->pclass == PlayerClassType::BLUE_MAGE)
 730         || player_ptr->pclass == PlayerClassType::ELEMENTALIST) {
 731         levels = player_ptr->lev;
 732     } else {
 733         if (mp_ptr->spell_first > player_ptr->lev) {
 734             player_ptr->msp = 0;
 735             set_bits(player_ptr->redraw, PR_MANA);
 736             return;
 737         }
 738
 739         levels = (player_ptr->lev - mp_ptr->spell_first) + 1;
 740     }
 741
 742     int msp;
 743     if (player_ptr->pclass == PlayerClassType::SAMURAI) {
 744         msp = (adj_mag_mana[player_ptr->stat_index[mp_ptr->spell_stat]] + 10) * 2;
 745         if (msp)
 746             msp += (msp * rp_ptr->r_adj[mp_ptr->spell_stat] / 20);
 747     } else {
 748         msp = adj_mag_mana[player_ptr->stat_index[mp_ptr->spell_stat]] * (levels + 3) / 4;
 749         if (msp)
 750             msp++;
 751         if (msp)
 752             msp += (msp * rp_ptr->r_adj[mp_ptr->spell_stat] / 20);
 753         if (msp && (player_ptr->ppersonality == PERSONALITY_MUNCHKIN))
 754             msp += msp / 2;
 755         if (msp && (player_ptr->pclass == PlayerClassType::HIGH_MAGE))
 756             msp += msp / 4;
 757         if (msp && (player_ptr->pclass == PlayerClassType::SORCERER))
 758             msp += msp * (25 + player_ptr->lev) / 100;
 759     }
 760
 761     if (any_bits(mp_ptr->spell_xtra, extra_magic_glove_reduce_mana)) {
 762         player_ptr->cumber_glove = false;
 763         object_type *o_ptr;
 764         o_ptr = &player_ptr->inventory_list[INVEN_ARMS];
 765         auto flgs = object_flags(o_ptr);
 766         if (o_ptr->k_idx && flgs.has_not(TR_FREE_ACT) && flgs.has_not(TR_DEC_MANA) && flgs.has_not(TR_EASY_SPELL)
 767             && !((flgs.has(TR_MAGIC_MASTERY)) && (o_ptr->pval > 0)) && !((flgs.has(TR_DEX)) && (o_ptr->pval > 0))) {
 768             player_ptr->cumber_glove = true;
 769             msp = (3 * msp) / 4;
 770         }
 771     }
 772
 773     player_ptr->cumber_armor = false;
 774
 775     int cur_wgt = 0;
 776     if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval > ItemKindType::SWORD)
 777         cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight;
 778     if (player_ptr->inventory_list[INVEN_SUB_HAND].tval > ItemKindType::SWORD)
 779         cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight;
 780     cur_wgt += player_ptr->inventory_list[INVEN_BODY].weight;
 781     cur_wgt += player_ptr->inventory_list[INVEN_HEAD].weight;
 782     cur_wgt += player_ptr->inventory_list[INVEN_OUTER].weight;
 783     cur_wgt += player_ptr->inventory_list[INVEN_ARMS].weight;
 784     cur_wgt += player_ptr->inventory_list[INVEN_FEET].weight;
 785
 786     switch (player_ptr->pclass) {
 787     case PlayerClassType::MAGE:
 788     case PlayerClassType::HIGH_MAGE:
 789     case PlayerClassType::BLUE_MAGE:
 790     case PlayerClassType::MONK:
 791     case PlayerClassType::FORCETRAINER:
 792     case PlayerClassType::SORCERER:
 793     case PlayerClassType::ELEMENTALIST: {
 794         if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
 795             cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight;
 796         if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
 797             cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight;
 798         break;
 799     }
 800     case PlayerClassType::PRIEST:
 801     case PlayerClassType::BARD:
 802     case PlayerClassType::TOURIST: {
 803         if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
 804             cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight * 2 / 3;
 805         if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
 806             cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight * 2 / 3;
 807         break;
 808     }
 809     case PlayerClassType::MINDCRAFTER:
 810     case PlayerClassType::BEASTMASTER:
 811     case PlayerClassType::MIRROR_MASTER: {
 812         if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
 813             cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight / 2;
 814         if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
 815             cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight / 2;
 816         break;
 817     }
 818     case PlayerClassType::ROGUE:
 819     case PlayerClassType::RANGER:
 820     case PlayerClassType::RED_MAGE:
 821     case PlayerClassType::WARRIOR_MAGE: {
 822         if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
 823             cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight / 3;
 824         if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
 825             cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight / 3;
 826         break;
 827     }
 828     case PlayerClassType::PALADIN:
 829     case PlayerClassType::CHAOS_WARRIOR: {
 830         if (player_ptr->inventory_list[INVEN_MAIN_HAND].tval <= ItemKindType::SWORD)
 831             cur_wgt += player_ptr->inventory_list[INVEN_MAIN_HAND].weight / 5;
 832         if (player_ptr->inventory_list[INVEN_SUB_HAND].tval <= ItemKindType::SWORD)
 833             cur_wgt += player_ptr->inventory_list[INVEN_SUB_HAND].weight / 5;
 834         break;
 835     }
 836     default: {
 837         break;
 838     }
 839     }
 840
 841     int max_wgt = mp_ptr->spell_weight;
 842     if ((cur_wgt - max_wgt) > 0) {
 843         player_ptr->cumber_armor = true;
 844         switch (player_ptr->pclass) {
 845         case PlayerClassType::MAGE:
 846         case PlayerClassType::HIGH_MAGE:
 847         case PlayerClassType::BLUE_MAGE:
 848         case PlayerClassType::ELEMENTALIST: {
 849             msp -= msp * (cur_wgt - max_wgt) / 600;
 850             break;
 851         }
 852         case PlayerClassType::PRIEST:
 853         case PlayerClassType::MINDCRAFTER:
 854         case PlayerClassType::BEASTMASTER:
 855         case PlayerClassType::BARD:
 856         case PlayerClassType::FORCETRAINER:
 857         case PlayerClassType::TOURIST:
 858         case PlayerClassType::MIRROR_MASTER: {
 859             msp -= msp * (cur_wgt - max_wgt) / 800;
 860             break;
 861         }
 862         case PlayerClassType::SORCERER: {
 863             msp -= msp * (cur_wgt - max_wgt) / 900;
 864             break;
 865         }
 866         case PlayerClassType::ROGUE:
 867         case PlayerClassType::RANGER:
 868         case PlayerClassType::MONK:
 869         case PlayerClassType::RED_MAGE: {
 870             msp -= msp * (cur_wgt - max_wgt) / 1000;
 871             break;
 872         }
 873         case PlayerClassType::PALADIN:
 874         case PlayerClassType::CHAOS_WARRIOR:
 875         case PlayerClassType::WARRIOR_MAGE: {
 876             msp -= msp * (cur_wgt - max_wgt) / 1200;
 877             break;
 878         }
 879         case PlayerClassType::SAMURAI: {
 880             player_ptr->cumber_armor = false;
 881             break;
 882         }
 883         default: {
 884             msp -= msp * (cur_wgt - max_wgt) / 800;
 885             break;
 886         }
 887         }
 888     }
 889
 890     if (msp < 0)
 891         msp = 0;
 892
 893     if (player_ptr->msp != msp) {
 894         if ((player_ptr->csp >= msp) && (player_ptr->pclass != PlayerClassType::SAMURAI)) {
 895             player_ptr->csp = msp;
 896             player_ptr->csp_frac = 0;
 897         }
 898
 899 #ifdef JP
 900         if (player_ptr->level_up_message && (msp > player_ptr->msp)) {
 901             msg_format("最大マジック・ポイントが %d 増加した！", (msp - player_ptr->msp));
 902         }
 903 #endif
 904         player_ptr->msp = msp;
 905         set_bits(player_ptr->redraw, PR_MANA);
 906         set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
 907     }
 908
 909     if (w_ptr->character_xtra)
 910         return;
 911
 912     if (player_ptr->old_cumber_glove != player_ptr->cumber_glove) {
 913         if (player_ptr->cumber_glove)
 914             msg_print(_("手が覆われて呪文が唱えにくい感じがする。", "Your covered hands feel unsuitable for spellcasting."));
 915         else
 916             msg_print(_("この手の状態なら、ぐっと呪文が唱えやすい感じだ。", "Your hands feel more suitable for spellcasting."));
 917
 918         player_ptr->old_cumber_glove = player_ptr->cumber_glove;
 919     }
 920
 921     if (player_ptr->old_cumber_armor == player_ptr->cumber_armor)
 922         return;
 923
 924     if (player_ptr->cumber_armor)
 925         msg_print(_("装備の重さで動きが鈍くなってしまっている。", "The weight of your equipment encumbers your movement."));
 926     else
 927         msg_print(_("ぐっと楽に体を動かせるようになった。", "You feel able to move more freely."));
 928
 929     player_ptr->old_cumber_armor = player_ptr->cumber_armor;
 930 }
 931
 932 /*!
 933  * @brief 装備中の射撃武器の威力倍率を返す /
 934  * calcurate the fire rate of target object
 935  * @param o_ptr 計算する射撃武器のアイテム情報参照ポインタ
 936  * @return 射撃倍率の値(100で1.00倍)
 937  */
 938 int16_t calc_num_fire(player_type *player_ptr, object_type *o_ptr)
 939 {
 940     int extra_shots = 0;
 941
 942     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
 943         object_type *q_ptr;
 944         q_ptr = &player_ptr->inventory_list[i];
 945         if (!q_ptr->k_idx)
 946             continue;
 947
 948         if (i == INVEN_BOW)
 949             continue;
 950
 951         auto flgs = object_flags(q_ptr);
 952         if (flgs.has(TR_XTRA_SHOTS))
 953             extra_shots++;
 954     }
 955
 956     auto flgs = object_flags(o_ptr);
 957     if (flgs.has(TR_XTRA_SHOTS))
 958         extra_shots++;
 959
 960     int num = 0;
 961     if (o_ptr->k_idx == 0)
 962         return (int16_t)num;
 963
 964     num = 100;
 965     num += (extra_shots * 100);
 966
 967     if (is_heavy_shoot(player_ptr, o_ptr))
 968         return (int16_t)num;
 969
 970     ItemKindType tval_ammo = bow_tval_ammo(o_ptr);
 971     if ((player_ptr->pclass == PlayerClassType::RANGER) && (tval_ammo == ItemKindType::ARROW)) {
 972         num += (player_ptr->lev * 4);
 973     }
 974
 975     if ((player_ptr->pclass == PlayerClassType::CAVALRY) && (tval_ammo == ItemKindType::ARROW)) {
 976         num += (player_ptr->lev * 3);
 977     }
 978
 979     if (player_ptr->pclass == PlayerClassType::ARCHER) {
 980         if (tval_ammo == ItemKindType::ARROW)
 981             num += ((player_ptr->lev * 5) + 50);
 982         else if ((tval_ammo == ItemKindType::BOLT) || (tval_ammo == ItemKindType::SHOT))
 983             num += (player_ptr->lev * 4);
 984     }
 985
 986     if (player_ptr->pclass == PlayerClassType::WARRIOR && (tval_ammo <= ItemKindType::BOLT) && (tval_ammo >= ItemKindType::SHOT)) {
 987         num += (player_ptr->lev * 2);
 988     }
 989
 990     if ((player_ptr->pclass == PlayerClassType::ROGUE) && (tval_ammo == ItemKindType::SHOT)) {
 991         num += (player_ptr->lev * 4);
 992     }
 993
 994     return (int16_t)num;
 995 }
 996
 997 /*!
 998  * @brief 解除能力計算
 999  * @param player_ptr プレイヤーへの参照ポインタ
1000  * @return 解除能力
1001  * @details
1002  * * 種族/職業/性格による加算
1003  * * 職業と性格とレベルによる追加加算
1004  * * 器用さに応じたadj_dex_disテーブルによる加算
1005  * * 知力に応じたadj_int_disテーブルによる加算
1006  */
1007 static ACTION_SKILL_POWER calc_disarming(player_type *player_ptr)
1008 {
1009     ACTION_SKILL_POWER pow;
1010     const player_race_info *tmp_rp_ptr;
1011
1012     if (player_ptr->mimic_form)
1013         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1014     else
1015         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1016     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1017     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1018
1019     pow = tmp_rp_ptr->r_dis + c_ptr->c_dis + a_ptr->a_dis;
1020     pow += ((cp_ptr->x_dis * player_ptr->lev / 10) + (ap_ptr->a_dis * player_ptr->lev / 50));
1021     pow += adj_dex_dis[player_ptr->stat_index[A_DEX]];
1022     pow += adj_int_dis[player_ptr->stat_index[A_INT]];
1023     return pow;
1024 }
1025
1026 /*!
1027  * @brief 魔道具使用能力計算
1028  * @param player_ptr プレイヤーへの参照ポインタ
1029  * @return 魔道具使用能力
1030  * @details
1031  * * 種族/職業/性格による加算
1032  * * 職業と性格とレベルによる追加加算
1033  * * 装備による加算(TR_MAGIC_MASTERYを持っていたら+pval*8)
1034  * * 知力に応じたadj_int_devテーブルによる加算
1035  * * 狂戦士化による減算(-20)
1036  */
1037 static ACTION_SKILL_POWER calc_device_ability(player_type *player_ptr)
1038 {
1039     ACTION_SKILL_POWER pow;
1040     const player_race_info *tmp_rp_ptr;
1041
1042     if (player_ptr->mimic_form)
1043         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1044     else
1045         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1046     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1047     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1048
1049     pow = tmp_rp_ptr->r_dev + c_ptr->c_dev + a_ptr->a_dev;
1050     pow += ((c_ptr->x_dev * player_ptr->lev / 10) + (ap_ptr->a_dev * player_ptr->lev / 50));
1051
1052     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1053         object_type *o_ptr;
1054         o_ptr = &player_ptr->inventory_list[i];
1055         if (!o_ptr->k_idx)
1056             continue;
1057         auto flgs = object_flags(o_ptr);
1058         if (flgs.has(TR_MAGIC_MASTERY))
1059             pow += 8 * o_ptr->pval;
1060     }
1061
1062     pow += adj_int_dev[player_ptr->stat_index[A_INT]];
1063
1064     if (is_shero(player_ptr)) {
1065         pow -= 20;
1066     }
1067     return pow;
1068 }
1069
1070 /*!
1071  * @brief 魔法防御計算
1072  * @param player_ptr プレイヤーへの参照ポインタ
1073  * @return 魔法防御
1074  * @details
1075  * * 種族/職業/性格による加算
1076  * * 職業と性格とレベルによる追加加算
1077  * * 変異MUT3_MAGIC_RESによる加算(15 + レベル / 5)
1078  * * 呪力耐性の装備による加算(30)
1079  * * 祝福された装備による加算(5 + レベル / 10)
1080  * * 賢さによるadj_wis_savテーブル加算
1081  * * 狂戦士化による減算(-30)
1082  * * 反魔法持ちで大なり上書き(90+レベル未満ならその値に上書き)
1083  * * クターのつぶれ状態なら(10に上書き)
1084  * * 生命の「究極の耐性」や regist_magic,magicdef持ちなら大なり上書き(95+レベル未満ならその値に上書き)
1085  * * 呪いのdown_savingがかかっているなら半減
1086  */
1087 static ACTION_SKILL_POWER calc_saving_throw(player_type *player_ptr)
1088 {
1089     ACTION_SKILL_POWER pow;
1090     const player_race_info *tmp_rp_ptr;
1091
1092     if (player_ptr->mimic_form)
1093         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1094     else
1095         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1096     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1097     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1098
1099     pow = tmp_rp_ptr->r_sav + c_ptr->c_sav + a_ptr->a_sav;
1100     pow += ((cp_ptr->x_sav * player_ptr->lev / 10) + (ap_ptr->a_sav * player_ptr->lev / 50));
1101
1102     if (player_ptr->muta.has(PlayerMutationType::MAGIC_RES))
1103         pow += (15 + (player_ptr->lev / 5));
1104
1105     if (has_resist_curse(player_ptr))
1106         pow += 30;
1107
1108     if (player_ptr->bless_blade)
1109         pow += 6 + (player_ptr->lev - 1) / 10;
1110
1111     pow += adj_wis_sav[player_ptr->stat_index[A_WIS]];
1112
1113     if (is_shero(player_ptr))
1114         pow -= 30;
1115
1116     if (player_ptr->anti_magic && (pow < (90 + player_ptr->lev)))
1117         pow = 90 + player_ptr->lev;
1118
1119     if (player_ptr->tsubureru)
1120         pow = 10;
1121
1122     if ((player_ptr->ult_res || player_ptr->resist_magic || player_ptr->magicdef) && (pow < (95 + player_ptr->lev)))
1123         pow = 95 + player_ptr->lev;
1124
1125     if (player_ptr->down_saving)
1126         pow /= 2;
1127
1128     return pow;
1129 }
1130
1131 /*!
1132  * @brief 探索深度計算
1133  * @param player_ptr プレイヤーへの参照ポインタ
1134  * @return 探索深度
1135  * @details
1136  * * 種族/職業/性格による加算
1137  * * 職業とレベルによる追加加算
1138  * * 各装備による加算(TR_SEARCHがあれば+pval*5)
1139  * * 狂戦士化による減算(-15)
1140  * * 変異(MUT3_XTRA_EYES)による加算(+15)
1141  */
1142 static ACTION_SKILL_POWER calc_search(player_type *player_ptr)
1143 {
1144     ACTION_SKILL_POWER pow;
1145     const player_race_info *tmp_rp_ptr;
1146
1147     if (player_ptr->mimic_form)
1148         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1149     else
1150         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1151     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1152     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1153
1154     pow = tmp_rp_ptr->r_srh + c_ptr->c_srh + a_ptr->a_srh;
1155     pow += (c_ptr->x_srh * player_ptr->lev / 10);
1156
1157     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1158         object_type *o_ptr;
1159         o_ptr = &player_ptr->inventory_list[i];
1160         if (!o_ptr->k_idx)
1161             continue;
1162         auto flgs = object_flags(o_ptr);
1163         if (flgs.has(TR_SEARCH))
1164             pow += (o_ptr->pval * 5);
1165     }
1166
1167     if (player_ptr->muta.has(PlayerMutationType::XTRA_EYES)) {
1168         pow += 15;
1169     }
1170
1171     if (is_shero(player_ptr)) {
1172         pow -= 15;
1173     }
1174
1175     return pow;
1176 }
1177
1178 /*!
1179  * @brief 探索頻度計算
1180  * @param player_ptr プレイヤーへの参照ポインタ
1181  * @return 探索頻度
1182  * @details
1183  * * 種族/職業/性格による加算
1184  * * 職業とレベルによる追加加算
1185  * * 各装備による加算(TR_SEARCHがあれば+pval*5)
1186  * * 狂戦士化による減算(-15)
1187  * * 変異(MUT3_XTRA_EYES)による加算(+15)
1188  */
1189 static ACTION_SKILL_POWER calc_search_freq(player_type *player_ptr)
1190 {
1191     ACTION_SKILL_POWER pow;
1192     const player_race_info *tmp_rp_ptr;
1193
1194     if (player_ptr->mimic_form)
1195         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1196     else
1197         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1198     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1199     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1200
1201     pow = tmp_rp_ptr->r_fos + c_ptr->c_fos + a_ptr->a_fos;
1202     pow += (c_ptr->x_fos * player_ptr->lev / 10);
1203
1204     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1205         object_type *o_ptr;
1206         o_ptr = &player_ptr->inventory_list[i];
1207         if (!o_ptr->k_idx)
1208             continue;
1209         auto flgs = object_flags(o_ptr);
1210         if (flgs.has(TR_SEARCH))
1211             pow += (o_ptr->pval * 5);
1212     }
1213
1214     if (is_shero(player_ptr)) {
1215         pow -= 15;
1216     }
1217
1218     if (player_ptr->muta.has(PlayerMutationType::XTRA_EYES)) {
1219         pow += 15;
1220     }
1221
1222     return pow;
1223 }
1224
1225 /*!
1226  * @brief 打撃命中能力計算
1227  * @param player_ptr プレイヤーへの参照ポインタ
1228  * @return 打撃命中能力
1229  * @details
1230  * * 種族/職業/性格による加算とレベルによる追加加算
1231  */
1232 static ACTION_SKILL_POWER calc_to_hit_melee(player_type *player_ptr)
1233 {
1234     ACTION_SKILL_POWER pow;
1235     const player_race_info *tmp_rp_ptr;
1236     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1237     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1238
1239     if (player_ptr->mimic_form)
1240         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1241     else
1242         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1243
1244     pow = tmp_rp_ptr->r_thn + c_ptr->c_thn + a_ptr->a_thn;
1245     pow += ((c_ptr->x_thn * player_ptr->lev / 10) + (a_ptr->a_thn * player_ptr->lev / 50));
1246     return pow;
1247 }
1248
1249 /*!
1250  * @brief 射撃命中能力計算
1251  * @param player_ptr プレイヤーへの参照ポインタ
1252  * @return 射撃命中能力
1253  * @details
1254  * * 種族/職業/性格による加算とレベルによる追加加算
1255  */
1256 static ACTION_SKILL_POWER calc_to_hit_shoot(player_type *player_ptr)
1257 {
1258     ACTION_SKILL_POWER pow;
1259     const player_race_info *tmp_rp_ptr;
1260     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1261     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1262
1263     if (player_ptr->mimic_form)
1264         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1265     else
1266         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1267
1268     pow = tmp_rp_ptr->r_thb + c_ptr->c_thb + a_ptr->a_thb;
1269     pow += ((c_ptr->x_thb * player_ptr->lev / 10) + (a_ptr->a_thb * player_ptr->lev / 50));
1270     return pow;
1271 }
1272
1273 /*!
1274  * @brief 投擲命中能力計算
1275  * @param player_ptr プレイヤーへの参照ポインタ
1276  * @return 投擲命中能力
1277  * @details
1278  * * 種族/職業/性格による加算とレベルによる追加加算
1279  * * 狂戦士による減算(-20)
1280  */
1281 static ACTION_SKILL_POWER calc_to_hit_throw(player_type *player_ptr)
1282 {
1283     ACTION_SKILL_POWER pow;
1284     const player_race_info *tmp_rp_ptr;
1285     const player_class_info *c_ptr = &class_info[enum2i(player_ptr->pclass)];
1286     const player_personality *a_ptr = &personality_info[player_ptr->ppersonality];
1287
1288     if (player_ptr->mimic_form)
1289         tmp_rp_ptr = &mimic_info[player_ptr->mimic_form];
1290     else
1291         tmp_rp_ptr = &race_info[enum2i(player_ptr->prace)];
1292
1293     pow = tmp_rp_ptr->r_thb + c_ptr->c_thb + a_ptr->a_thb;
1294     pow += ((c_ptr->x_thb * player_ptr->lev / 10) + (a_ptr->a_thb * player_ptr->lev / 50));
1295
1296     if (is_shero(player_ptr)) {
1297         pow -= 20;
1298     }
1299
1300     return pow;
1301 }
1302
1303 /*!
1304  * @brief 掘削能力計算
1305  * @param player_ptr プレイヤーへの参照ポインタ
1306  * @return 掘削能力値
1307  * @details
1308  * * エントが素手の場合のプラス修正
1309  * * 狂戦士化時のプラス修正
1310  * * 腕力によるテーブルプラス修正
1311  * * 職業狂戦士のプラス修正
1312  * * 装備の特性によるプラス修正
1313  * * 武器重量によるプラス修正
1314  * * 最終算出値に1を保証
1315  */
1316 static ACTION_SKILL_POWER calc_skill_dig(player_type *player_ptr)
1317 {
1318     object_type *o_ptr;
1319
1320     ACTION_SKILL_POWER pow;
1321
1322     pow = 0;
1323
1324     if (!player_ptr->mimic_form && player_ptr->prace == PlayerRaceType::ENT && !player_ptr->inventory_list[INVEN_MAIN_HAND].k_idx) {
1325         pow += player_ptr->lev * 10;
1326     }
1327
1328     if (is_shero(player_ptr))
1329         pow += 30;
1330
1331     pow += adj_str_dig[player_ptr->stat_index[A_STR]];
1332
1333     if (player_ptr->pclass == PlayerClassType::BERSERKER)
1334         pow += (100 + player_ptr->lev * 8);
1335
1336     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1337         o_ptr = &player_ptr->inventory_list[i];
1338         if (!o_ptr->k_idx)
1339             continue;
1340         auto flgs = object_flags(o_ptr);
1341         if (flgs.has(TR_TUNNEL))
1342             pow += (o_ptr->pval * 20);
1343     }
1344
1345     for (int i = 0; i < 2; i++) {
1346         o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
1347         if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i) && !player_ptr->heavy_wield[i]) {
1348             pow += (o_ptr->weight / 10);
1349         }
1350     }
1351
1352     if (is_shero(player_ptr)) {
1353         pow += 30;
1354     }
1355
1356     if (pow < 1)
1357         pow = 1;
1358
1359     return pow;
1360 }
1361
1362 static bool is_martial_arts_mode(player_type *player_ptr)
1363 {
1364     return ((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER) || (player_ptr->pclass == PlayerClassType::BERSERKER))
1365         && (any_bits(empty_hands(player_ptr, true), EMPTY_HAND_MAIN)) && !can_attack_with_sub_hand(player_ptr);
1366 }
1367
1368 static bool is_heavy_wield(player_type *player_ptr, int i)
1369 {
1370     const object_type *o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
1371
1372     return has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i) && (calc_weapon_weight_limit(player_ptr) < o_ptr->weight / 10);
1373 }
1374
1375 static int16_t calc_num_blow(player_type *player_ptr, int i)
1376 {
1377     object_type *o_ptr;
1378     int16_t num_blow = 1;
1379
1380     o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND + i];
1381     auto flgs = object_flags(o_ptr);
1382     if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i)) {
1383         if (o_ptr->k_idx && !player_ptr->heavy_wield[i]) {
1384             int str_index, dex_index;
1385             int num = 0, wgt = 0, mul = 0, div = 0;
1386
1387             auto &info = class_info[enum2i(player_ptr->pclass)];
1388             num = info.num;
1389             wgt = info.wgt;
1390             mul = info.mul;
1391
1392             if (player_ptr->pclass == PlayerClassType::CAVALRY && (player_ptr->riding) && (flgs.has(TR_RIDING))) {
1393                 num = 5;
1394                 wgt = 70;
1395                 mul = 4;
1396             }
1397
1398             if (SpellHex(player_ptr).is_spelling_specific(HEX_XTRA_MIGHT) || SpellHex(player_ptr).is_spelling_specific(HEX_BUILDING)) {
1399                 num++;
1400                 wgt /= 2;
1401                 mul += 2;
1402             }
1403
1404             div = ((o_ptr->weight < wgt) ? wgt : o_ptr->weight);
1405             str_index = (adj_str_blow[player_ptr->stat_index[A_STR]] * mul / div);
1406
1407             if (has_two_handed_weapons(player_ptr) && !has_disable_two_handed_bonus(player_ptr, 0))
1408                 str_index += (player_ptr->pclass == PlayerClassType::WARRIOR || player_ptr->pclass == PlayerClassType::BERSERKER) ? (player_ptr->lev / 23 + 1) : 1;
1409             if (player_ptr->pclass == PlayerClassType::NINJA)
1410                 str_index = std::max(0, str_index - 1);
1411             if (str_index > 11)
1412                 str_index = 11;
1413
1414             dex_index = (adj_dex_blow[player_ptr->stat_index[A_DEX]]);
1415             if (dex_index > 11)
1416                 dex_index = 11;
1417
1418             num_blow = blows_table[str_index][dex_index];
1419             if (num_blow > num)
1420                 num_blow = (int16_t)num;
1421
1422             num_blow += (int16_t)player_ptr->extra_blows[i];
1423             if (player_ptr->pclass == PlayerClassType::WARRIOR)
1424                 num_blow += (player_ptr->lev / 40);
1425             else if (player_ptr->pclass == PlayerClassType::BERSERKER)
1426                 num_blow += (player_ptr->lev / 23);
1427             else if ((player_ptr->pclass == PlayerClassType::ROGUE) && (o_ptr->weight < 50) && (player_ptr->stat_index[A_DEX] >= 30))
1428                 num_blow++;
1429
1430             if (PlayerClass(player_ptr).samurai_stance_is(SamuraiStance::FUUJIN))
1431                 num_blow -= 1;
1432
1433             if ((o_ptr->tval == ItemKindType::SWORD) && (o_ptr->sval == SV_POISON_NEEDLE))
1434                 num_blow = 1;
1435
1436             if (num_blow < 1)
1437                 num_blow = 1;
1438         }
1439     }
1440
1441     if (i != 0)
1442         return num_blow;
1443     /* Different calculation for monks with empty hands */
1444     if (is_martial_arts_mode(player_ptr)) {
1445         int blow_base = player_ptr->lev + adj_dex_blow[player_ptr->stat_index[A_DEX]];
1446         num_blow = 0;
1447
1448         if (player_ptr->pclass == PlayerClassType::FORCETRAINER) {
1449             if (blow_base > 18)
1450                 num_blow++;
1451             if (blow_base > 31)
1452                 num_blow++;
1453             if (blow_base > 44)
1454                 num_blow++;
1455             if (blow_base > 58)
1456                 num_blow++;
1457         } else {
1458             if (blow_base > 12)
1459                 num_blow++;
1460             if (blow_base > 22)
1461                 num_blow++;
1462             if (blow_base > 31)
1463                 num_blow++;
1464             if (blow_base > 39)
1465                 num_blow++;
1466             if (blow_base > 46)
1467                 num_blow++;
1468             if (blow_base > 53)
1469                 num_blow++;
1470             if (blow_base > 59)
1471                 num_blow++;
1472         }
1473
1474         if (heavy_armor(player_ptr) && (player_ptr->pclass != PlayerClassType::BERSERKER))
1475             num_blow /= 2;
1476
1477         PlayerClass pc(player_ptr);
1478         if (pc.monk_stance_is(MonkStance::GENBU)) {
1479             num_blow -= 2;
1480             if ((player_ptr->pclass == PlayerClassType::MONK) && (player_ptr->lev > 42))
1481                 num_blow--;
1482             if (num_blow < 0)
1483                 num_blow = 0;
1484         } else if (pc.monk_stance_is(MonkStance::SUZAKU)) {
1485             num_blow /= 2;
1486         }
1487
1488         num_blow += 1 + player_ptr->extra_blows[0];
1489     }
1490
1491     if (has_not_ninja_weapon(player_ptr, i)) {
1492         num_blow /= 2;
1493         if (num_blow < 1)
1494             num_blow = 1;
1495     }
1496
1497     return num_blow;
1498 }
1499
1500 /*!
1501  * @brief 魔法失敗値計算
1502  * @param player_ptr プレイヤーへの参照ポインタ
1503  * @return 魔法失敗値
1504  * @details
1505  * * 性格なまけものなら加算(+10)
1506  * * 性格きれものなら減算(-3)
1507  * * 性格ちからじまんとがまんづよいなら加算(+1)
1508  * * 性格チャージマンなら加算(+5)
1509  * * 装備品にTRC::HARD_SPELLがあるなら加算(軽い呪いなら+3/重い呪いなら+10)
1510  */
1511 static int16_t calc_to_magic_chance(player_type *player_ptr)
1512 {
1513     int16_t chance = 0;
1514
1515     if (player_ptr->ppersonality == PERSONALITY_LAZY)
1516         chance += 10;
1517     if (player_ptr->ppersonality == PERSONALITY_SHREWD)
1518         chance -= 3;
1519     if ((player_ptr->ppersonality == PERSONALITY_PATIENT) || (player_ptr->ppersonality == PERSONALITY_MIGHTY))
1520         chance++;
1521     if (player_ptr->ppersonality == PERSONALITY_CHARGEMAN)
1522         chance += 5;
1523
1524     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1525         object_type *o_ptr;
1526         o_ptr = &player_ptr->inventory_list[i];
1527         if (!o_ptr->k_idx)
1528             continue;
1529
1530         if (o_ptr->curse_flags.has(TRC::HARD_SPELL)) {
1531             if (o_ptr->curse_flags.has(TRC::HEAVY_CURSE)) {
1532                 chance += 10;
1533             } else {
1534                 chance += 3;
1535             }
1536         }
1537     }
1538     return chance;
1539 }
1540
1541 static ARMOUR_CLASS calc_base_ac(player_type *player_ptr)
1542 {
1543     ARMOUR_CLASS ac = 0;
1544     if (player_ptr->yoiyami)
1545         return 0;
1546
1547     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1548         object_type *o_ptr;
1549         o_ptr = &player_ptr->inventory_list[i];
1550         if (!o_ptr->k_idx)
1551             continue;
1552         ac += o_ptr->ac;
1553     }
1554
1555     const auto o_ptr_mh = &player_ptr->inventory_list[INVEN_MAIN_HAND];
1556     const auto o_ptr_sh = &player_ptr->inventory_list[INVEN_SUB_HAND];
1557     if (o_ptr_mh->is_armour() || o_ptr_sh->is_armour()) {
1558         ac += player_ptr->skill_exp[PlayerSkillKindType::SHIELD] * (1 + player_ptr->lev / 22) / 2000;
1559     }
1560
1561     return ac;
1562 }
1563
1564 static ARMOUR_CLASS calc_to_ac(player_type *player_ptr, bool is_real_value)
1565 {
1566     ARMOUR_CLASS ac = 0;
1567     if (player_ptr->yoiyami)
1568         return 0;
1569
1570     ac += ((int)(adj_dex_ta[player_ptr->stat_index[A_DEX]]) - 128);
1571
1572     if (player_ptr->mimic_form) {
1573         switch (player_ptr->mimic_form) {
1574         case MIMIC_DEMON:
1575             ac += 10;
1576             break;
1577         case MIMIC_DEMON_LORD:
1578             ac += 20;
1579             break;
1580         case MIMIC_VAMPIRE:
1581             ac += 10;
1582         }
1583     }
1584
1585     if (player_ptr->pclass == PlayerClassType::BERSERKER) {
1586         ac += 10 + player_ptr->lev / 2;
1587     }
1588     if (player_ptr->pclass == PlayerClassType::SORCERER) {
1589         ac -= 50;
1590     }
1591
1592     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1593         object_type *o_ptr;
1594         o_ptr = &player_ptr->inventory_list[i];
1595         auto flags = object_flags(o_ptr);
1596         if (!o_ptr->k_idx)
1597             continue;
1598         if (is_real_value || o_ptr->is_known())
1599             ac += o_ptr->to_a;
1600
1601         if (o_ptr->curse_flags.has(TRC::LOW_AC)) {
1602             if (o_ptr->curse_flags.has(TRC::HEAVY_CURSE)) {
1603                 if (is_real_value || o_ptr->is_fully_known())
1604                     ac -= 30;
1605             } else {
1606                 if (is_real_value || o_ptr->is_fully_known())
1607                     ac -= 10;
1608             }
1609         }
1610
1611         if ((i == INVEN_SUB_HAND) && flags.has(TR_SUPPORTIVE)) {
1612             ac += 5;
1613         }
1614     }
1615
1616     if (PlayerRace(player_ptr).equals(PlayerRaceType::GOLEM) || PlayerRace(player_ptr).equals(PlayerRaceType::ANDROID)) {
1617         ac += 10 + (player_ptr->lev * 2 / 5);
1618     }
1619
1620     if ((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_QUICKTHORN) && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_TINYTHORN)) {
1621         ac += 10;
1622     }
1623
1624     if ((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_MUSASI_KATANA)
1625         && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_MUSASI_WAKIZASI)) {
1626         ac += 10;
1627     }
1628
1629     if ((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_ICINGDEATH) && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_TWINKLE)) {
1630         ac += 5;
1631     }
1632
1633     if (player_ptr->muta.has(PlayerMutationType::WART_SKIN)) {
1634         ac += 5;
1635     }
1636
1637     if (player_ptr->muta.has(PlayerMutationType::SCALES)) {
1638         ac += 10;
1639     }
1640
1641     if (player_ptr->muta.has(PlayerMutationType::IRON_SKIN)) {
1642         ac += 25;
1643     }
1644
1645     if (((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER)) && !heavy_armor(player_ptr)) {
1646         if (!(player_ptr->inventory_list[INVEN_BODY].k_idx)) {
1647             ac += (player_ptr->lev * 3) / 2;
1648         }
1649         if (!(player_ptr->inventory_list[INVEN_OUTER].k_idx) && (player_ptr->lev > 15)) {
1650             ac += ((player_ptr->lev - 13) / 3);
1651         }
1652         if (!(player_ptr->inventory_list[INVEN_SUB_HAND].k_idx) && (player_ptr->lev > 10)) {
1653             ac += ((player_ptr->lev - 8) / 3);
1654         }
1655         if (!(player_ptr->inventory_list[INVEN_HEAD].k_idx) && (player_ptr->lev > 4)) {
1656             ac += (player_ptr->lev - 2) / 3;
1657         }
1658         if (!(player_ptr->inventory_list[INVEN_ARMS].k_idx)) {
1659             ac += (player_ptr->lev / 2);
1660         }
1661         if (!(player_ptr->inventory_list[INVEN_FEET].k_idx)) {
1662             ac += (player_ptr->lev / 3);
1663         }
1664     }
1665
1666     if (player_ptr->realm1 == REALM_HEX) {
1667         if (SpellHex(player_ptr).is_spelling_specific(HEX_ICE_ARMOR)) {
1668             ac += 30;
1669         }
1670
1671         for (int i = INVEN_MAIN_HAND; i <= INVEN_FEET; i++) {
1672             object_type *o_ptr = &player_ptr->inventory_list[i];
1673             if (!o_ptr->k_idx)
1674                 continue;
1675             if (!o_ptr->is_armour())
1676                 continue;
1677             if (!o_ptr->is_cursed())
1678                 continue;
1679             if (o_ptr->curse_flags.has(TRC::CURSED))
1680                 ac += 5;
1681             if (o_ptr->curse_flags.has(TRC::HEAVY_CURSE))
1682                 ac += 7;
1683             if (o_ptr->curse_flags.has(TRC::PERMA_CURSE))
1684                 ac += 13;
1685         }
1686     }
1687
1688     PlayerClass pc(player_ptr);
1689     if (pc.monk_stance_is(MonkStance::GENBU)) {
1690         ac += (player_ptr->lev * player_ptr->lev) / 50;
1691     } else if (pc.monk_stance_is(MonkStance::BYAKKO)) {
1692         ac -= 40;
1693     } else if (pc.monk_stance_is(MonkStance::SEIRYU)) {
1694         ac -= 50;
1695     } else if (pc.samurai_stance_is(SamuraiStance::KOUKIJIN)) {
1696         ac -= 50;
1697     }
1698
1699     if (player_ptr->ult_res || (pc.samurai_stance_is(SamuraiStance::MUSOU))) {
1700         ac += 100;
1701     } else if (player_ptr->tsubureru || player_ptr->shield || player_ptr->magicdef) {
1702         ac += 50;
1703     }
1704
1705     if (is_blessed(player_ptr)) {
1706         ac += 5;
1707     }
1708
1709     if (is_shero(player_ptr)) {
1710         ac -= 10;
1711     }
1712
1713     if (player_ptr->pclass == PlayerClassType::NINJA) {
1714         if ((!player_ptr->inventory_list[INVEN_MAIN_HAND].k_idx || can_attack_with_main_hand(player_ptr))
1715             && (!player_ptr->inventory_list[INVEN_SUB_HAND].k_idx || can_attack_with_sub_hand(player_ptr))) {
1716             ac += player_ptr->lev / 2 + 5;
1717         }
1718     }
1719
1720     return ac;
1721 }
1722
1723 /*!
1724  * @brief 二刀流ペナルティ量計算
1725  * @param player_ptr プレイヤーへの参照ポインタ
1726  * @param slot ペナルティ量を計算する武器スロット
1727  * @return 二刀流ペナルティ量
1728  * @details
1729  * * 二刀流にしていなければ0
1730  * * 特別セットによる軽減
1731  * * EASY2_WEAPONによる軽減
1732  * * SUPPORTIVEを左に装備した場合の軽減
1733  * * 武蔵セットによる免除
1734  * * 竿状武器による増加
1735  */
1736 int16_t calc_double_weapon_penalty(player_type *player_ptr, INVENTORY_IDX slot)
1737 {
1738     int penalty = 0;
1739
1740     if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND) && has_melee_weapon(player_ptr, INVEN_SUB_HAND)) {
1741         auto flags = object_flags(&player_ptr->inventory_list[INVEN_SUB_HAND]);
1742
1743         penalty = ((100 - player_ptr->skill_exp[PlayerSkillKindType::TWO_WEAPON] / 160) - (130 - player_ptr->inventory_list[slot].weight) / 8);
1744         if (((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_QUICKTHORN) && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_TINYTHORN))
1745             || ((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_ICINGDEATH)
1746                 && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_TWINKLE))) {
1747             penalty = penalty / 2 - 5;
1748         }
1749
1750         for (uint i = FLAG_CAUSE_INVEN_MAIN_HAND; i < FLAG_CAUSE_MAX; i <<= 1)
1751             if (penalty > 0 && any_bits(player_ptr->easy_2weapon, i))
1752                 penalty /= 2;
1753
1754         if (flags.has(TR_SUPPORTIVE))
1755             penalty = std::max(0, penalty - 10);
1756
1757         if ((player_ptr->inventory_list[INVEN_MAIN_HAND].name1 == ART_MUSASI_KATANA)
1758             && (player_ptr->inventory_list[INVEN_SUB_HAND].name1 == ART_MUSASI_WAKIZASI)) {
1759             penalty = std::min(0, penalty);
1760         }
1761
1762         if (player_ptr->inventory_list[slot].tval == ItemKindType::POLEARM)
1763             penalty += 10;
1764     }
1765     return (int16_t)penalty;
1766 }
1767
1768 static bool is_riding_two_hands(player_type *player_ptr)
1769 {
1770     if (!player_ptr->riding) {
1771         return false;
1772     }
1773
1774     if (has_two_handed_weapons(player_ptr) || (empty_hands(player_ptr, false) == EMPTY_HAND_NONE))
1775         return true;
1776     else if (any_bits(player_ptr->pet_extra_flags, PF_TWO_HANDS)) {
1777         switch (player_ptr->pclass) {
1778         case PlayerClassType::MONK:
1779         case PlayerClassType::FORCETRAINER:
1780         case PlayerClassType::BERSERKER:
1781             if ((empty_hands(player_ptr, false) != EMPTY_HAND_NONE) && !has_melee_weapon(player_ptr, INVEN_MAIN_HAND)
1782                 && !has_melee_weapon(player_ptr, INVEN_SUB_HAND))
1783                 return true;
1784
1785         default:
1786             break;
1787         }
1788     }
1789
1790     return false;
1791 }
1792
1793 static int16_t calc_riding_bow_penalty(player_type *player_ptr)
1794 {
1795     floor_type *floor_ptr = player_ptr->current_floor_ptr;
1796     if (!player_ptr->riding)
1797         return 0;
1798
1799     int16_t penalty = 0;
1800
1801     if ((player_ptr->pclass == PlayerClassType::BEASTMASTER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) {
1802         if (player_ptr->tval_ammo != ItemKindType::ARROW)
1803             penalty = 5;
1804     } else {
1805         penalty = r_info[floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[PlayerSkillKindType::RIDING] / 80;
1806         penalty += 30;
1807         if (penalty < 30)
1808             penalty = 30;
1809     }
1810
1811     if (player_ptr->tval_ammo == ItemKindType::BOLT)
1812         penalty *= 2;
1813
1814     return penalty;
1815 }
1816
1817 void put_equipment_warning(player_type *player_ptr)
1818 {
1819     bool heavy_shoot = is_heavy_shoot(player_ptr, &player_ptr->inventory_list[INVEN_BOW]);
1820     if (player_ptr->old_heavy_shoot != heavy_shoot) {
1821         if (heavy_shoot) {
1822             msg_print(_("こんな重い弓を装備しているのは大変だ。", "You have trouble wielding such a heavy bow."));
1823         } else if (player_ptr->inventory_list[INVEN_BOW].k_idx) {
1824             msg_print(_("この弓なら装備していても辛くない。", "You have no trouble wielding your bow."));
1825         } else {
1826             msg_print(_("重い弓を装備からはずして体が楽になった。", "You feel relieved to put down your heavy bow."));
1827         }
1828         player_ptr->old_heavy_shoot = heavy_shoot;
1829     }
1830
1831     for (int i = 0; i < 2; i++) {
1832         if (player_ptr->old_heavy_wield[i] != player_ptr->heavy_wield[i]) {
1833             if (player_ptr->heavy_wield[i]) {
1834                 msg_print(_("こんな重い武器を装備しているのは大変だ。", "You have trouble wielding such a heavy weapon."));
1835             } else if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i)) {
1836                 msg_print(_("これなら装備していても辛くない。", "You have no trouble wielding your weapon."));
1837             } else if (player_ptr->heavy_wield[1 - i]) {
1838                 msg_print(_("まだ武器が重い。", "You still have trouble wielding a heavy weapon."));
1839             } else {
1840                 msg_print(_("重い武器を装備からはずして体が楽になった。", "You feel relieved to put down your heavy weapon."));
1841             }
1842
1843             player_ptr->old_heavy_wield[i] = player_ptr->heavy_wield[i];
1844         }
1845
1846         if (player_ptr->old_riding_wield[i] != player_ptr->is_icky_riding_wield[i]) {
1847             if (player_ptr->is_icky_riding_wield[i]) {
1848                 msg_print(_("この武器は乗馬中に使うにはむかないようだ。", "This weapon is not suitable for use while riding."));
1849             } else if (!player_ptr->riding) {
1850                 msg_print(_("この武器は徒歩で使いやすい。", "This weapon is suitable for use on foot."));
1851             } else if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i)) {
1852                 msg_print(_("これなら乗馬中にぴったりだ。", "This weapon is suitable for use while riding."));
1853             }
1854
1855             player_ptr->old_riding_wield[i] = player_ptr->is_icky_riding_wield[i];
1856         }
1857
1858         if (player_ptr->old_icky_wield[i] == player_ptr->is_icky_wield[i])
1859             continue;
1860
1861         if (player_ptr->is_icky_wield[i]) {
1862             msg_print(_("今の装備はどうも自分にふさわしくない気がする。", "You do not feel comfortable with your weapon."));
1863             if (w_ptr->is_loading_now) {
1864                 chg_virtue(player_ptr, V_FAITH, -1);
1865             }
1866         } else if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND + i)) {
1867             msg_print(_("今の装備は自分にふさわしい気がする。", "You feel comfortable with your weapon."));
1868         } else {
1869             msg_print(_("装備をはずしたら随分と気が楽になった。", "You feel more comfortable after removing your weapon."));
1870         }
1871
1872         player_ptr->old_icky_wield[i] = player_ptr->is_icky_wield[i];
1873     }
1874
1875     if (player_ptr->riding && (player_ptr->old_riding_ryoute != player_ptr->riding_ryoute)) {
1876         if (player_ptr->riding_ryoute) {
1877 #ifdef JP
1878             msg_format("%s馬を操れない。", (empty_hands(player_ptr, false) == EMPTY_HAND_NONE) ? "両手がふさがっていて" : "");
1879 #else
1880             msg_print("You are using both hand for fighting, and you can't control the pet you're riding.");
1881 #endif
1882         } else {
1883 #ifdef JP
1884             msg_format("%s馬を操れるようになった。", (empty_hands(player_ptr, false) == EMPTY_HAND_NONE) ? "手が空いて" : "");
1885 #else
1886             msg_print("You began to control the pet you're riding with one hand.");
1887 #endif
1888         }
1889
1890         player_ptr->old_riding_ryoute = player_ptr->riding_ryoute;
1891     }
1892
1893     if (((player_ptr->pclass == PlayerClassType::MONK) || (player_ptr->pclass == PlayerClassType::FORCETRAINER) || (player_ptr->pclass == PlayerClassType::NINJA))
1894         && (heavy_armor(player_ptr) != player_ptr->monk_notify_aux)) {
1895         if (heavy_armor(player_ptr)) {
1896             msg_print(_("装備が重くてバランスを取れない。", "The weight of your armor disrupts your balance."));
1897             if (w_ptr->is_loading_now) {
1898                 chg_virtue(player_ptr, V_HARMONY, -1);
1899             }
1900         } else {
1901             msg_print(_("バランスがとれるようになった。", "You regain your balance."));
1902         }
1903
1904         player_ptr->monk_notify_aux = heavy_armor(player_ptr);
1905     }
1906 }
1907
1908 static short calc_to_damage(player_type *player_ptr, INVENTORY_IDX slot, bool is_real_value)
1909 {
1910     object_type *o_ptr = &player_ptr->inventory_list[slot];
1911     auto flgs = object_flags(o_ptr);
1912
1913     player_hand calc_hand = PLAYER_HAND_OTHER;
1914     if (slot == INVEN_MAIN_HAND)
1915         calc_hand = PLAYER_HAND_MAIN;
1916     if (slot == INVEN_SUB_HAND)
1917         calc_hand = PLAYER_HAND_SUB;
1918
1919     auto damage = 0;
1920     damage += ((int)(adj_str_td[player_ptr->stat_index[A_STR]]) - 128);
1921
1922     if (is_shero(player_ptr)) {
1923         damage += 3 + (player_ptr->lev / 5);
1924     }
1925
1926     auto player_stun = player_ptr->effects()->stun();
1927     damage -= player_stun->get_damage_penalty();
1928     if ((player_ptr->pclass == PlayerClassType::PRIEST) && (flgs.has_not(TR_BLESSED)) && ((o_ptr->tval == ItemKindType::SWORD) || (o_ptr->tval == ItemKindType::POLEARM))) {
1929         damage -= 2;
1930     } else if (player_ptr->pclass == PlayerClassType::BERSERKER) {
1931         damage += player_ptr->lev / 6;
1932         if (((calc_hand == PLAYER_HAND_MAIN) && !can_attack_with_sub_hand(player_ptr)) || has_two_handed_weapons(player_ptr)) {
1933             damage += player_ptr->lev / 6;
1934         }
1935     } else if (player_ptr->pclass == PlayerClassType::SORCERER) {
1936         if (!((o_ptr->tval == ItemKindType::HAFTED) && ((o_ptr->sval == SV_WIZSTAFF) || (o_ptr->sval == SV_NAMAKE_HAMMER)))) {
1937             damage -= 200;
1938         } else {
1939             damage -= 10;
1940         }
1941     } else if (player_ptr->pclass == PlayerClassType::FORCETRAINER) {
1942         // 練気術師は格闘ダメージに (気)/5 の修正を得る。
1943         if (is_martial_arts_mode(player_ptr) && calc_hand == PLAYER_HAND_MAIN) {
1944             damage += get_current_ki(player_ptr) / 5;
1945         }
1946     }
1947
1948     if ((player_ptr->realm1 == REALM_HEX) && o_ptr->is_cursed()) {
1949         if (SpellHex(player_ptr).is_spelling_specific(HEX_RUNESWORD)) {
1950             if (o_ptr->curse_flags.has(TRC::CURSED)) {
1951                 damage += 5;
1952             }
1953             if (o_ptr->curse_flags.has(TRC::HEAVY_CURSE)) {
1954                 damage += 7;
1955             }
1956             if (o_ptr->curse_flags.has(TRC::PERMA_CURSE)) {
1957                 damage += 13;
1958             }
1959         }
1960     }
1961
1962     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
1963         int bonus_to_d = 0;
1964         o_ptr = &player_ptr->inventory_list[i];
1965         if (!o_ptr->k_idx || o_ptr->tval == ItemKindType::CAPTURE || (i == INVEN_MAIN_HAND && has_melee_weapon(player_ptr, i))
1966             || (i == INVEN_SUB_HAND && has_melee_weapon(player_ptr, i)) || i == INVEN_BOW)
1967             continue;
1968
1969         if (!o_ptr->is_known() && !is_real_value)
1970             continue;
1971         bonus_to_d = o_ptr->to_d;
1972
1973         if (player_ptr->pclass == PlayerClassType::NINJA) {
1974             if (o_ptr->to_d > 0)
1975                 bonus_to_d = (o_ptr->to_d + 1) / 2;
1976         }
1977
1978         switch (player_melee_type(player_ptr)) {
1979         case MELEE_TYPE_BAREHAND_TWO: /* fall through */
1980         case MELEE_TYPE_WEAPON_TWOHAND:
1981             if (calc_hand == main_attack_hand(player_ptr))
1982                 damage += (int16_t)bonus_to_d;
1983             break;
1984
1985         case MELEE_TYPE_BAREHAND_MAIN: /* fall through */
1986         case MELEE_TYPE_WEAPON_MAIN:
1987             if ((calc_hand == PLAYER_HAND_MAIN) && (i != INVEN_SUB_RING))
1988                 damage += (int16_t)bonus_to_d;
1989             break;
1990
1991         case MELEE_TYPE_BAREHAND_SUB: /* fall through */
1992         case MELEE_TYPE_WEAPON_SUB:
1993             if ((calc_hand == PLAYER_HAND_SUB) && (i != INVEN_MAIN_RING))
1994                 damage += (int16_t)bonus_to_d;
1995             break;
1996
1997         case MELEE_TYPE_WEAPON_DOUBLE:
1998             if (calc_hand == PLAYER_HAND_MAIN) {
1999                 if (i == INVEN_MAIN_RING) {
2000                     damage += (int16_t)bonus_to_d;
2001                 } else if (i != INVEN_SUB_RING) {
2002                     damage += (bonus_to_d > 0) ? (bonus_to_d + 1) / 2 : bonus_to_d;
2003                 }
2004             }
2005             if (calc_hand == PLAYER_HAND_SUB) {
2006                 if (i == INVEN_SUB_RING) {
2007                     damage += (int16_t)bonus_to_d;
2008                 } else if (i != INVEN_MAIN_RING) {
2009                     damage += (bonus_to_d > 0) ? bonus_to_d / 2 : bonus_to_d;
2010                 }
2011             }
2012             break;
2013
2014         case MELEE_TYPE_SHIELD_DOUBLE:
2015             break;
2016
2017         default:
2018             break;
2019         }
2020     }
2021
2022     if (main_attack_hand(player_ptr) == calc_hand) {
2023         if ((is_martial_arts_mode(player_ptr) && empty_hands(player_ptr, false) == (EMPTY_HAND_MAIN | EMPTY_HAND_SUB))
2024             || !has_disable_two_handed_bonus(player_ptr, calc_hand)) {
2025             int bonus_to_d = 0;
2026             bonus_to_d = ((int)(adj_str_td[player_ptr->stat_index[A_STR]]) - 128) / 2;
2027             damage += std::max<int>(bonus_to_d, 1);
2028         }
2029     }
2030
2031     if (is_martial_arts_mode(player_ptr) && (!heavy_armor(player_ptr) || player_ptr->pclass != PlayerClassType::BERSERKER)) {
2032         damage += (player_ptr->lev / 6);
2033     }
2034
2035     // 朱雀の構えをとっているとき、格闘ダメージに -(レベル)/6 の修正を得る。
2036     if (PlayerClass(player_ptr).monk_stance_is(MonkStance::SUZAKU)) {
2037         if (is_martial_arts_mode(player_ptr) && calc_hand == PLAYER_HAND_MAIN) {
2038             damage -= (player_ptr->lev / 6);
2039         }
2040     }
2041
2042     return static_cast<short>(damage);
2043 }
2044
2045 /*!
2046  * @brief 武器の命中修正を計算する。 / Calculate hit bonus from a wielded weapon.
2047  * @details
2048  * 'slot' MUST be INVEN_MAIN_HAND or INVEM_SUB_HAND.
2049  */
2050 static short calc_to_hit(player_type *player_ptr, INVENTORY_IDX slot, bool is_real_value)
2051 {
2052     auto hit = 0;
2053
2054     /* Base bonuses */
2055     hit += ((int)(adj_dex_th[player_ptr->stat_index[A_DEX]]) - 128);
2056     hit += ((int)(adj_str_th[player_ptr->stat_index[A_STR]]) - 128);
2057
2058     /* Temporary bonuses */
2059     if (is_blessed(player_ptr)) {
2060         hit += 10;
2061     }
2062
2063     if (is_hero(player_ptr)) {
2064         hit += 12;
2065     }
2066
2067     if (is_shero(player_ptr)) {
2068         hit += 12;
2069     }
2070
2071     auto player_stun = player_ptr->effects()->stun();
2072     hit -= player_stun->get_damage_penalty();
2073     player_hand calc_hand = PLAYER_HAND_OTHER;
2074     if (slot == INVEN_MAIN_HAND)
2075         calc_hand = PLAYER_HAND_MAIN;
2076     if (slot == INVEN_SUB_HAND)
2077         calc_hand = PLAYER_HAND_SUB;
2078
2079     /* Default hand bonuses */
2080     if (main_attack_hand(player_ptr) == calc_hand) {
2081         switch (player_melee_type(player_ptr)) {
2082         case MELEE_TYPE_BAREHAND_MAIN:
2083             if (player_ptr->riding)
2084                 break;
2085             /* fall through */
2086         case MELEE_TYPE_BAREHAND_SUB:
2087             if (player_ptr->riding)
2088                 break;
2089             /* fall through */
2090         case MELEE_TYPE_BAREHAND_TWO:
2091             hit += (player_ptr->skill_exp[PlayerSkillKindType::MARTIAL_ARTS] - PlayerSkill::weapon_exp_at(PlayerSkillRank::BEGINNER)) / 200;
2092             break;
2093
2094         default:
2095             break;
2096         }
2097
2098         if ((is_martial_arts_mode(player_ptr) && empty_hands(player_ptr, false) == (EMPTY_HAND_MAIN | EMPTY_HAND_SUB))
2099             || !has_disable_two_handed_bonus(player_ptr, calc_hand)) {
2100             int bonus_to_h = 0;
2101             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);
2102             hit += std::max<int>(bonus_to_h, 1);
2103         }
2104     }
2105
2106     /* Bonuses and penalties by weapon */
2107     if (has_melee_weapon(player_ptr, slot)) {
2108         object_type *o_ptr = &player_ptr->inventory_list[slot];
2109         auto flgs = object_flags(o_ptr);
2110
2111         /* Traind bonuses */
2112         hit += (player_ptr->weapon_exp[o_ptr->tval][o_ptr->sval] - PlayerSkill::weapon_exp_at(PlayerSkillRank::BEGINNER)) / 200;
2113
2114         /* Weight penalty */
2115         if (calc_weapon_weight_limit(player_ptr) < o_ptr->weight / 10) {
2116             hit += 2 * (calc_weapon_weight_limit(player_ptr) - o_ptr->weight / 10);
2117         }
2118
2119         /* Low melee penalty */
2120         if ((o_ptr->is_fully_known() || is_real_value) && o_ptr->curse_flags.has(TRC::LOW_MELEE)) {
2121             if (o_ptr->curse_flags.has(TRC::HEAVY_CURSE)) {
2122                 hit -= 15;
2123             } else {
2124                 hit -= 5;
2125             }
2126         }
2127
2128         /* Riding bonus and penalty */
2129         if (player_ptr->riding > 0) {
2130             if (o_ptr->is_lance()) {
2131                 hit += 15;
2132             } else if (flgs.has_not(TR_RIDING)) {
2133                 short penalty;
2134                 if ((player_ptr->pclass == PlayerClassType::BEASTMASTER) || (player_ptr->pclass == PlayerClassType::CAVALRY)) {
2135                     penalty = 5;
2136                 } else {
2137                     penalty = r_info[player_ptr->current_floor_ptr->m_list[player_ptr->riding].r_idx].level - player_ptr->skill_exp[PlayerSkillKindType::RIDING] / 80;
2138                     penalty += 30;
2139                     if (penalty < 30) {
2140                         penalty = 30;
2141                     }
2142                 }
2143
2144                 hit -= penalty;
2145             }
2146         }
2147
2148         /* Class penalties */
2149         if ((player_ptr->pclass == PlayerClassType::PRIEST) && (flgs.has_not(TR_BLESSED)) && ((o_ptr->tval == ItemKindType::SWORD) || (o_ptr->tval == ItemKindType::POLEARM))) {
2150             hit -= 2;
2151         } else if (player_ptr->pclass == PlayerClassType::BERSERKER) {
2152             hit += player_ptr->lev / 5;
2153             if (((calc_hand == PLAYER_HAND_MAIN) && !can_attack_with_sub_hand(player_ptr)) || has_two_handed_weapons(player_ptr)) {
2154                 hit += player_ptr->lev / 5;
2155             }
2156         } else if (player_ptr->pclass == PlayerClassType::SORCERER) {
2157             if (!((o_ptr->tval == ItemKindType::HAFTED) && ((o_ptr->sval == SV_WIZSTAFF) || (o_ptr->sval == SV_NAMAKE_HAMMER)))) {
2158                 hit -= 200;
2159             } else {
2160                 hit -= 30;
2161             }
2162         }
2163
2164         if (has_not_ninja_weapon(player_ptr, (int)calc_hand) || has_not_monk_weapon(player_ptr, (int)calc_hand)) {
2165             hit -= 40;
2166         }
2167
2168         /* Hex realm bonuses */
2169         if ((player_ptr->realm1 == REALM_HEX) && o_ptr->is_cursed()) {
2170             if (o_ptr->curse_flags.has(TRC::CURSED)) {
2171                 hit += 5;
2172             }
2173             if (o_ptr->curse_flags.has(TRC::HEAVY_CURSE)) {
2174                 hit += 7;
2175             }
2176             if (o_ptr->curse_flags.has(TRC::PERMA_CURSE)) {
2177                 hit += 13;
2178             }
2179             if (o_ptr->curse_flags.has(TRC::TY_CURSE)) {
2180                 hit += 5;
2181             }
2182         }
2183     }
2184
2185     /* Bonuses from inventory */
2186     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
2187         object_type *o_ptr = &player_ptr->inventory_list[i];
2188
2189         /* Ignore empty hands, handed weapons, bows and capture balls */
2190         if (!o_ptr->k_idx || o_ptr->tval == ItemKindType::CAPTURE || (i == INVEN_MAIN_HAND && has_melee_weapon(player_ptr, i))
2191             || (i == INVEN_SUB_HAND && has_melee_weapon(player_ptr, i)) || i == INVEN_BOW)
2192             continue;
2193
2194         /* Fake value does not include unknown objects' value */
2195         if (!o_ptr->is_known() && !is_real_value)
2196             continue;
2197
2198         int bonus_to_h = o_ptr->to_h;
2199
2200         /* When wields only a weapon */
2201         if (player_ptr->pclass == PlayerClassType::NINJA) {
2202             if (o_ptr->to_h > 0)
2203                 bonus_to_h = (o_ptr->to_h + 1) / 2;
2204         }
2205
2206         switch (player_melee_type(player_ptr)) {
2207         case MELEE_TYPE_BAREHAND_TWO: /* fall through */
2208         case MELEE_TYPE_WEAPON_TWOHAND:
2209             if (calc_hand == main_attack_hand(player_ptr))
2210                 hit += (int16_t)bonus_to_h;
2211             break;
2212
2213         case MELEE_TYPE_BAREHAND_MAIN: /* fall through */
2214         case MELEE_TYPE_WEAPON_MAIN:
2215             if ((calc_hand == PLAYER_HAND_MAIN) && (i != INVEN_SUB_RING))
2216                 hit += (int16_t)bonus_to_h;
2217             break;
2218
2219         case MELEE_TYPE_BAREHAND_SUB: /* fall through */
2220         case MELEE_TYPE_WEAPON_SUB:
2221             if ((calc_hand == PLAYER_HAND_SUB) && (i != INVEN_MAIN_RING))
2222                 hit += (int16_t)bonus_to_h;
2223             break;
2224
2225         case MELEE_TYPE_WEAPON_DOUBLE:
2226             if (calc_hand == PLAYER_HAND_MAIN) {
2227                 if (i == INVEN_MAIN_RING) {
2228                     hit += (int16_t)bonus_to_h;
2229                 } else if (i != INVEN_SUB_RING) {
2230                     hit += (bonus_to_h > 0) ? (bonus_to_h + 1) / 2 : bonus_to_h;
2231                 }
2232             }
2233             if (calc_hand == PLAYER_HAND_SUB) {
2234                 if (i == INVEN_SUB_RING) {
2235                     hit += (int16_t)bonus_to_h;
2236                 } else if (i != INVEN_MAIN_RING) {
2237                     hit += (bonus_to_h > 0) ? bonus_to_h / 2 : bonus_to_h;
2238                 }
2239             }
2240             break;
2241
2242         case MELEE_TYPE_SHIELD_DOUBLE:
2243             break;
2244
2245         default:
2246             break;
2247         }
2248     }
2249
2250     /* Martial arts bonus */
2251     if (is_martial_arts_mode(player_ptr) && (!heavy_armor(player_ptr) || player_ptr->pclass != PlayerClassType::BERSERKER)) {
2252         hit += (player_ptr->lev / 3);
2253     }
2254
2255     /* Two handed combat penalty */
2256     hit -= calc_double_weapon_penalty(player_ptr, slot);
2257
2258     // 朱雀の構えをとっているとき、格闘命中に -(レベル)/3 の修正を得る。
2259     if (PlayerClass(player_ptr).monk_stance_is(MonkStance::SUZAKU)) {
2260         if (is_martial_arts_mode(player_ptr) && calc_hand == PLAYER_HAND_MAIN) {
2261             hit -= (player_ptr->lev / 3);
2262         }
2263     }
2264
2265     return static_cast<short>(hit);
2266 }
2267
2268 static int16_t calc_to_hit_bow(player_type *player_ptr, bool is_real_value)
2269 {
2270     int16_t pow = 0;
2271
2272     pow += ((int)(adj_dex_th[player_ptr->stat_index[A_DEX]]) - 128);
2273     pow += ((int)(adj_str_th[player_ptr->stat_index[A_STR]]) - 128);
2274
2275     {
2276         object_type *o_ptr;
2277         o_ptr = &player_ptr->inventory_list[INVEN_BOW];
2278         if (o_ptr->k_idx) {
2279             if (o_ptr->curse_flags.has(TRC::LOW_MELEE)) {
2280                 if (o_ptr->curse_flags.has(TRC::HEAVY_CURSE)) {
2281                     pow -= 15;
2282                 } else {
2283                     pow -= 5;
2284                 }
2285             }
2286         }
2287     }
2288
2289     auto player_stun = player_ptr->effects()->stun();
2290     pow -= player_stun->get_damage_penalty();
2291     if (is_blessed(player_ptr)) {
2292         pow += 10;
2293     }
2294
2295     if (is_hero(player_ptr)) {
2296         pow += 12;
2297     }
2298
2299     if (is_shero(player_ptr)) {
2300         pow -= 12;
2301     }
2302
2303     object_type *o_ptr = &player_ptr->inventory_list[INVEN_BOW];
2304
2305     if (is_heavy_shoot(player_ptr, o_ptr)) {
2306         pow += 2 * (calc_bow_weight_limit(player_ptr) - o_ptr->weight / 10);
2307     }
2308
2309     if (o_ptr->k_idx) {
2310         if (o_ptr->k_idx && !is_heavy_shoot(player_ptr, &player_ptr->inventory_list[INVEN_BOW])) {
2311             if ((player_ptr->pclass == PlayerClassType::SNIPER) && (player_ptr->tval_ammo == ItemKindType::BOLT)) {
2312                 pow += (10 + (player_ptr->lev / 5));
2313             }
2314         }
2315     }
2316
2317     // 武器以外の装備による修正
2318     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
2319         int bonus_to_h;
2320         o_ptr = &player_ptr->inventory_list[i];
2321         if (!o_ptr->k_idx || o_ptr->tval == ItemKindType::CAPTURE || (i == INVEN_MAIN_HAND && has_melee_weapon(player_ptr, i))
2322             || (i == INVEN_SUB_HAND && has_melee_weapon(player_ptr, i)) || i == INVEN_BOW)
2323             continue;
2324
2325         bonus_to_h = o_ptr->to_h;
2326
2327         if (player_ptr->pclass == PlayerClassType::NINJA) {
2328             if (o_ptr->to_h > 0)
2329                 bonus_to_h = (o_ptr->to_h + 1) / 2;
2330         }
2331
2332         if (is_real_value || o_ptr->is_known())
2333             pow += (int16_t)bonus_to_h;
2334     }
2335
2336     pow -= calc_riding_bow_penalty(player_ptr);
2337
2338     return pow;
2339 }
2340
2341 static int16_t calc_to_damage_misc(player_type *player_ptr)
2342 {
2343     object_type *o_ptr;
2344
2345     int16_t to_dam = 0;
2346
2347     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
2348         o_ptr = &player_ptr->inventory_list[i];
2349         if (!o_ptr->k_idx)
2350             continue;
2351
2352         int bonus_to_d = o_ptr->to_d;
2353         if (player_ptr->pclass == PlayerClassType::NINJA) {
2354             if (o_ptr->to_d > 0)
2355                 bonus_to_d = (o_ptr->to_d + 1) / 2;
2356         }
2357         to_dam += (int16_t)bonus_to_d;
2358     }
2359
2360     if (is_shero(player_ptr)) {
2361         to_dam += 3 + (player_ptr->lev / 5);
2362     }
2363
2364     auto player_stun = player_ptr->effects()->stun();
2365     to_dam -= player_stun->get_damage_penalty();
2366     to_dam += ((int)(adj_str_td[player_ptr->stat_index[A_STR]]) - 128);
2367     return to_dam;
2368 }
2369
2370 static int16_t calc_to_hit_misc(player_type *player_ptr)
2371 {
2372     object_type *o_ptr;
2373
2374     int16_t to_hit = 0;
2375
2376     for (int i = INVEN_MAIN_HAND; i < INVEN_TOTAL; i++) {
2377         o_ptr = &player_ptr->inventory_list[i];
2378         if (!o_ptr->k_idx)
2379             continue;
2380
2381         int bonus_to_h = o_ptr->to_h;
2382         if (player_ptr->pclass == PlayerClassType::NINJA) {
2383             if (o_ptr->to_h > 0)
2384                 bonus_to_h = (o_ptr->to_h + 1) / 2;
2385         }
2386         to_hit += (int16_t)bonus_to_h;
2387     }
2388
2389     if (is_blessed(player_ptr)) {
2390         to_hit += 10;
2391     }
2392
2393     if (is_hero(player_ptr)) {
2394         to_hit += 12;
2395     }
2396
2397     if (is_shero(player_ptr)) {
2398         to_hit += 12;
2399     }
2400
2401     auto player_stun = player_ptr->effects()->stun();
2402     to_hit -= player_stun->get_damage_penalty();
2403     to_hit += ((int)(adj_dex_th[player_ptr->stat_index[A_DEX]]) - 128);
2404     to_hit += ((int)(adj_str_th[player_ptr->stat_index[A_STR]]) - 128);
2405
2406     return to_hit;
2407 }
2408
2409 static DICE_NUMBER calc_to_weapon_dice_num(player_type *player_ptr, INVENTORY_IDX slot)
2410 {
2411     auto *o_ptr = &player_ptr->inventory_list[slot];
2412     return (player_ptr->riding > 0) && o_ptr->is_lance() ? 2 : 0;
2413 }
2414
2415 /*!
2416  * @brief プレイヤーの所持重量制限を計算する /
2417  * Computes current weight limit.
2418  * @return 制限重量(ポンド)
2419  */
2420 WEIGHT calc_weight_limit(player_type *player_ptr)
2421 {
2422     WEIGHT i = (WEIGHT)adj_str_wgt[player_ptr->stat_index[A_STR]] * 50;
2423     if (player_ptr->pclass == PlayerClassType::BERSERKER)
2424         i = i * 3 / 2;
2425     return i;
2426 }
2427
2428 /*!
2429  * @brief update のフラグに応じた更新をまとめて行う / Handle "update"
2430  * @details 更新処理の対象はプレイヤーの能力修正/光源寿命/HP/MP/魔法の学習状態、他多数の外界の状態判定。
2431  */
2432 void update_creature(player_type *player_ptr)
2433 {
2434     if (!player_ptr->update)
2435         return;
2436
2437     floor_type *floor_ptr = player_ptr->current_floor_ptr;
2438     if (any_bits(player_ptr->update, (PU_AUTODESTROY))) {
2439         reset_bits(player_ptr->update, PU_AUTODESTROY);
2440         autopick_delayed_alter(player_ptr);
2441     }
2442
2443     if (any_bits(player_ptr->update, (PU_COMBINE))) {
2444         reset_bits(player_ptr->update, PU_COMBINE);
2445         combine_pack(player_ptr);
2446     }
2447
2448     if (any_bits(player_ptr->update, (PU_REORDER))) {
2449         reset_bits(player_ptr->update, PU_REORDER);
2450         reorder_pack(player_ptr);
2451     }
2452
2453     if (any_bits(player_ptr->update, (PU_BONUS))) {
2454         reset_bits(player_ptr->update, PU_BONUS);
2455         PlayerAlignment(player_ptr).update_alignment();
2456         update_bonuses(player_ptr);
2457     }
2458
2459     if (any_bits(player_ptr->update, (PU_TORCH))) {
2460         reset_bits(player_ptr->update, PU_TORCH);
2461         update_lite_radius(player_ptr);
2462     }
2463
2464     if (any_bits(player_ptr->update, (PU_HP))) {
2465         reset_bits(player_ptr->update, PU_HP);
2466         update_max_hitpoints(player_ptr);
2467     }
2468
2469     if (any_bits(player_ptr->update, (PU_MANA))) {
2470         reset_bits(player_ptr->update, PU_MANA);
2471         update_max_mana(player_ptr);
2472     }
2473
2474     if (any_bits(player_ptr->update, (PU_SPELLS))) {
2475         reset_bits(player_ptr->update, PU_SPELLS);
2476         update_num_of_spells(player_ptr);
2477     }
2478
2479     if (!w_ptr->character_generated)
2480         return;
2481     if (w_ptr->character_icky_depth > 0)
2482         return;
2483     if (any_bits(player_ptr->update, (PU_UN_LITE))) {
2484         reset_bits(player_ptr->update, PU_UN_LITE);
2485         forget_lite(floor_ptr);
2486     }
2487
2488     if (any_bits(player_ptr->update, (PU_UN_VIEW))) {
2489         reset_bits(player_ptr->update, PU_UN_VIEW);
2490         forget_view(floor_ptr);
2491     }
2492
2493     if (any_bits(player_ptr->update, (PU_VIEW))) {
2494         reset_bits(player_ptr->update, PU_VIEW);
2495         update_view(player_ptr);
2496     }
2497
2498     if (any_bits(player_ptr->update, (PU_LITE))) {
2499         reset_bits(player_ptr->update, PU_LITE);
2500         update_lite(player_ptr);
2501     }
2502
2503     if (any_bits(player_ptr->update, (PU_FLOW))) {
2504         reset_bits(player_ptr->update, PU_FLOW);
2505         update_flow(player_ptr);
2506     }
2507
2508     if (any_bits(player_ptr->update, (PU_DISTANCE))) {
2509         reset_bits(player_ptr->update, PU_DISTANCE);
2510
2511         update_monsters(player_ptr, true);
2512     }
2513
2514     if (any_bits(player_ptr->update, (PU_MON_LITE))) {
2515         reset_bits(player_ptr->update, PU_MON_LITE);
2516         update_mon_lite(player_ptr);
2517     }
2518
2519     if (any_bits(player_ptr->update, (PU_DELAY_VIS))) {
2520         reset_bits(player_ptr->update, PU_DELAY_VIS);
2521         delayed_visual_update(player_ptr);
2522     }
2523
2524     if (any_bits(player_ptr->update, (PU_MONSTERS))) {
2525         reset_bits(player_ptr->update, PU_MONSTERS);
2526         update_monsters(player_ptr, false);
2527     }
2528 }
2529
2530 /*!
2531  * @brief プレイヤーが魔道書を一冊も持っていないかを判定する
2532  * @return 魔道書を一冊も持っていないならTRUEを返す
2533  */
2534 bool player_has_no_spellbooks(player_type *player_ptr)
2535 {
2536     object_type *o_ptr;
2537     for (int i = 0; i < INVEN_PACK; i++) {
2538         o_ptr = &player_ptr->inventory_list[i];
2539         if (o_ptr->k_idx && check_book_realm(player_ptr, o_ptr->tval, o_ptr->sval))
2540             return false;
2541     }
2542
2543     floor_type *floor_ptr = player_ptr->current_floor_ptr;
2544     for (const auto this_o_idx : floor_ptr->grid_array[player_ptr->y][player_ptr->x].o_idx_list) {
2545         o_ptr = &floor_ptr->o_list[this_o_idx];
2546         if (o_ptr->k_idx && any_bits(o_ptr->marked, OM_FOUND) && check_book_realm(player_ptr, o_ptr->tval, o_ptr->sval))
2547             return false;
2548     }
2549
2550     return true;
2551 }
2552
2553 /*!
2554  * @brief プレイヤーを指定座標に配置する / Place the player in the dungeon XXX XXX
2555  * @param x 配置先X座標
2556  * @param y 配置先Y座標
2557  * @return 配置に成功したらTRUE
2558  */
2559 bool player_place(player_type *player_ptr, POSITION y, POSITION x)
2560 {
2561     if (player_ptr->current_floor_ptr->grid_array[y][x].m_idx != 0)
2562         return false;
2563
2564     /* Save player location */
2565     player_ptr->y = y;
2566     player_ptr->x = x;
2567     return true;
2568 }
2569
2570 /*!
2571  * @brief 種族アンバライトが出血時パターンの上に乗った際のペナルティ処理
2572  */
2573 void wreck_the_pattern(player_type *player_ptr)
2574 {
2575     floor_type *floor_ptr = player_ptr->current_floor_ptr;
2576     int pattern_type = f_info[floor_ptr->grid_array[player_ptr->y][player_ptr->x].feat].subtype;
2577     if (pattern_type == PATTERN_TILE_WRECKED)
2578         return;
2579
2580     msg_print(_("パターンを血で汚してしまった！", "You bleed on the Pattern!"));
2581     msg_print(_("何か恐ろしい事が起こった！", "Something terrible happens!"));
2582
2583     if (!is_invuln(player_ptr))
2584         take_hit(player_ptr, DAMAGE_NOESCAPE, damroll(10, 8), _("パターン損壊", "corrupting the Pattern"));
2585
2586     int to_ruin = randint1(45) + 35;
2587     while (to_ruin--) {
2588         POSITION r_y, r_x;
2589         scatter(player_ptr, &r_y, &r_x, player_ptr->y, player_ptr->x, 4, PROJECT_NONE);
2590
2591         if (pattern_tile(floor_ptr, r_y, r_x) && (f_info[floor_ptr->grid_array[r_y][r_x].feat].subtype != PATTERN_TILE_WRECKED)) {
2592             cave_set_feat(player_ptr, r_y, r_x, feat_pattern_corrupted);
2593         }
2594     }
2595
2596     cave_set_feat(player_ptr, player_ptr->y, player_ptr->x, feat_pattern_corrupted);
2597 }
2598
2599 /*!
2600  * @brief プレイヤーの経験値について整合性のためのチェックと調整を行う /
2601  * Advance experience levels and print experience
2602  */
2603 void check_experience(player_type *player_ptr)
2604 {
2605     if (player_ptr->exp < 0)
2606         player_ptr->exp = 0;
2607     if (player_ptr->max_exp < 0)
2608         player_ptr->max_exp = 0;
2609     if (player_ptr->max_max_exp < 0)
2610         player_ptr->max_max_exp = 0;
2611
2612     if (player_ptr->exp > PY_MAX_EXP)
2613         player_ptr->exp = PY_MAX_EXP;
2614     if (player_ptr->max_exp > PY_MAX_EXP)
2615         player_ptr->max_exp = PY_MAX_EXP;
2616     if (player_ptr->max_max_exp > PY_MAX_EXP)
2617         player_ptr->max_max_exp = PY_MAX_EXP;
2618
2619     if (player_ptr->exp > player_ptr->max_exp)
2620         player_ptr->max_exp = player_ptr->exp;
2621     if (player_ptr->max_exp > player_ptr->max_max_exp)
2622         player_ptr->max_max_exp = player_ptr->max_exp;
2623
2624     set_bits(player_ptr->redraw, PR_EXP);
2625     handle_stuff(player_ptr);
2626
2627     bool android = player_ptr->prace == PlayerRaceType::ANDROID;
2628     PLAYER_LEVEL old_lev = player_ptr->lev;
2629     while ((player_ptr->lev > 1) && (player_ptr->exp < ((android ? player_exp_a : player_exp)[player_ptr->lev - 2] * player_ptr->expfact / 100L))) {
2630         player_ptr->lev--;
2631         set_bits(player_ptr->update, PU_BONUS | PU_HP | PU_MANA | PU_SPELLS);
2632         set_bits(player_ptr->redraw, PR_LEV | PR_TITLE);
2633         set_bits(player_ptr->window_flags, PW_PLAYER);
2634         handle_stuff(player_ptr);
2635     }
2636
2637     bool level_reward = false;
2638     bool level_mutation = false;
2639     bool level_inc_stat = false;
2640     while ((player_ptr->lev < PY_MAX_LEVEL)
2641         && (player_ptr->exp >= ((android ? player_exp_a : player_exp)[player_ptr->lev - 1] * player_ptr->expfact / 100L))) {
2642         player_ptr->lev++;
2643         if (player_ptr->lev > player_ptr->max_plv) {
2644             player_ptr->max_plv = player_ptr->lev;
2645
2646             if ((player_ptr->pclass == PlayerClassType::CHAOS_WARRIOR) || player_ptr->muta.has(PlayerMutationType::CHAOS_GIFT)) {
2647                 level_reward = true;
2648             }
2649             if (player_ptr->prace == PlayerRaceType::BEASTMAN) {
2650                 if (one_in_(5))
2651                     level_mutation = true;
2652             }
2653             level_inc_stat = true;
2654
2655             exe_write_diary(player_ptr, DIARY_LEVELUP, player_ptr->lev, nullptr);
2656         }
2657
2658         sound(SOUND_LEVEL);
2659         msg_format(_("レベル %d にようこそ。", "Welcome to level %d."), player_ptr->lev);
2660         set_bits(player_ptr->update, (PU_BONUS | PU_HP | PU_MANA | PU_SPELLS));
2661         set_bits(player_ptr->redraw, (PR_LEV | PR_TITLE | PR_EXP));
2662         set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL | PW_INVEN));
2663         player_ptr->level_up_message = true;
2664         handle_stuff(player_ptr);
2665
2666         player_ptr->level_up_message = false;
2667         if (level_inc_stat) {
2668             if (!(player_ptr->max_plv % 10)) {
2669                 int choice;
2670                 screen_save();
2671                 while (true) {
2672                     int n;
2673                     char tmp[32];
2674
2675                     cnv_stat(player_ptr->stat_max[0], tmp);
2676                     prt(format(_("        a) 腕力 (現在値 %s)", "        a) Str (cur %s)"), tmp), 2, 14);
2677                     cnv_stat(player_ptr->stat_max[1], tmp);
2678                     prt(format(_("        b) 知能 (現在値 %s)", "        b) Int (cur %s)"), tmp), 3, 14);
2679                     cnv_stat(player_ptr->stat_max[2], tmp);
2680                     prt(format(_("        c) 賢さ (現在値 %s)", "        c) Wis (cur %s)"), tmp), 4, 14);
2681                     cnv_stat(player_ptr->stat_max[3], tmp);
2682                     prt(format(_("        d) 器用 (現在値 %s)", "        d) Dex (cur %s)"), tmp), 5, 14);
2683                     cnv_stat(player_ptr->stat_max[4], tmp);
2684                     prt(format(_("        e) 耐久 (現在値 %s)", "        e) Con (cur %s)"), tmp), 6, 14);
2685                     cnv_stat(player_ptr->stat_max[5], tmp);
2686                     prt(format(_("        f) 魅力 (現在値 %s)", "        f) Chr (cur %s)"), tmp), 7, 14);
2687
2688                     prt("", 8, 14);
2689                     prt(_("        どの能力値を上げますか？", "        Which stat do you want to raise?"), 1, 14);
2690
2691                     while (true) {
2692                         choice = inkey();
2693                         if ((choice >= 'a') && (choice <= 'f'))
2694                             break;
2695                     }
2696                     for (n = 0; n < A_MAX; n++)
2697                         if (n != choice - 'a')
2698                             prt("", n + 2, 14);
2699                     if (get_check(_("よろしいですか？", "Are you sure? ")))
2700                         break;
2701                 }
2702                 do_inc_stat(player_ptr, choice - 'a');
2703                 screen_load();
2704             } else if (!(player_ptr->max_plv % 2))
2705                 do_inc_stat(player_ptr, randint0(6));
2706         }
2707
2708         if (level_mutation) {
2709             msg_print(_("あなたは変わった気がする...", "You feel different..."));
2710             (void)gain_mutation(player_ptr, 0);
2711             level_mutation = false;
2712         }
2713
2714         /*
2715          * 報酬でレベルが上ると再帰的に check_experience(player_ptr) が
2716          * 呼ばれるので順番を最後にする。
2717          */
2718         if (level_reward) {
2719             patron_list[player_ptr->chaos_patron].gain_level_reward(player_ptr, 0);
2720             level_reward = false;
2721         }
2722
2723         set_bits(player_ptr->update, PU_BONUS | PU_HP | PU_MANA | PU_SPELLS);
2724         set_bits(player_ptr->redraw, (PR_LEV | PR_TITLE));
2725         set_bits(player_ptr->window_flags, (PW_PLAYER | PW_SPELL));
2726         handle_stuff(player_ptr);
2727     }
2728
2729     if (old_lev != player_ptr->lev)
2730         autopick_load_pref(player_ptr, false);
2731 }
2732
2733 /*!
2734  * @brief 現在の修正後能力値を3～17及び18/xxx形式に変換する / Converts stat num into a six-char (right justified) string
2735  * @param val 能力値
2736  * @param out_val 出力先文字列ポインタ
2737  */
2738 void cnv_stat(int val, char *out_val)
2739 {
2740     if (val <= 18) {
2741         sprintf(out_val, "    %2d", val);
2742         return;
2743     }
2744
2745     int bonus = (val - 18);
2746     if (bonus >= 220) {
2747         sprintf(out_val, "18/%3s", "***");
2748     } else if (bonus >= 100) {
2749         sprintf(out_val, "18/%03d", bonus);
2750     } else {
2751         sprintf(out_val, " 18/%02d", bonus);
2752     }
2753 }
2754
2755 /*!
2756  * @brief 能力値現在値から3～17及び18/xxx様式に基づく加減算を行う。
2757  * Modify a stat value by a "modifier", return new value
2758  * @param value 現在値
2759  * @param amount 加減算値
2760  * @return 加減算後の値
2761  * @details
2762  * <pre>
2763  * Stats go up: 3,4,...,17,18,18/10,18/20,...,18/220
2764  * Or even: 18/13, 18/23, 18/33, ..., 18/220
2765  * Stats go down: 18/220, 18/210,..., 18/10, 18, 17, ..., 3
2766  * Or even: 18/13, 18/03, 18, 17, ..., 3
2767  * </pre>
2768  */
2769 int16_t modify_stat_value(int value, int amount)
2770 {
2771     if (amount > 0) {
2772         for (int i = 0; i < amount; i++) {
2773             if (value < 18)
2774                 value++;
2775             else
2776                 value += 10;
2777         }
2778     } else if (amount < 0) {
2779         for (int i = 0; i < (0 - amount); i++) {
2780             if (value >= 18 + 10)
2781                 value -= 10;
2782             else if (value > 18)
2783                 value = 18;
2784             else if (value > 3)
2785                 value--;
2786         }
2787     }
2788
2789     return (int16_t)value;
2790 }
2791
2792 /*!
2793  * @brief スコアを計算する /
2794  * Hack -- Calculates the total number of points earned         -JWT-
2795  * @details
2796  */
2797 long calc_score(player_type *player_ptr)
2798 {
2799     int arena_win = std::min<int>(player_ptr->arena_number, MAX_ARENA_MONS);
2800
2801     int mult = 100;
2802     if (!preserve_mode)
2803         mult += 10;
2804     if (!autoroller)
2805         mult += 10;
2806     if (!smart_learn)
2807         mult -= 20;
2808     if (smart_cheat)
2809         mult += 30;
2810     if (ironman_shops)
2811         mult += 50;
2812     if (ironman_small_levels)
2813         mult += 10;
2814     if (ironman_empty_levels)
2815         mult += 20;
2816     if (!powerup_home)
2817         mult += 50;
2818     if (ironman_rooms)
2819         mult += 100;
2820     if (ironman_nightmare)
2821         mult += 100;
2822
2823     if (mult < 5)
2824         mult = 5;
2825
2826     DEPTH max_dl = 0;
2827     for (const auto &d_ref : d_info)
2828         if (max_dl < max_dlv[d_ref.idx])
2829             max_dl = max_dlv[d_ref.idx];
2830
2831     uint32_t point_l = (player_ptr->max_max_exp + (100 * max_dl));
2832     uint32_t point_h = point_l / 0x10000L;
2833     point_l = point_l % 0x10000L;
2834     point_h *= mult;
2835     point_l *= mult;
2836     point_h += point_l / 0x10000L;
2837     point_l %= 0x10000L;
2838
2839     point_l += ((point_h % 100) << 16);
2840     point_h /= 100;
2841     point_l /= 100;
2842
2843     uint32_t point = (point_h << 16) + (point_l);
2844     if (player_ptr->arena_number >= 0)
2845         point += (arena_win * arena_win * (arena_win > 29 ? 1000 : 100));
2846
2847     if (ironman_downward)
2848         point *= 2;
2849     if (player_ptr->pclass == PlayerClassType::BERSERKER) {
2850         if (player_ptr->prace == PlayerRaceType::SPECTRE)
2851             point = point / 5;
2852     }
2853
2854     if ((player_ptr->ppersonality == PERSONALITY_MUNCHKIN) && point) {
2855         point = 1;
2856         if (w_ptr->total_winner)
2857             point = 2;
2858     }
2859
2860     return point;
2861 }
2862
2863 /*!
2864  * @param player_ptr プレイヤーへの参照ポインタ
2865  * @return 祝福状態ならばTRUE
2866  */
2867 bool is_blessed(player_type *player_ptr)
2868 {
2869     return player_ptr->blessed || music_singing(player_ptr, MUSIC_BLESS) || SpellHex(player_ptr).is_spelling_specific(HEX_BLESS);
2870 }
2871
2872 bool is_tim_esp(player_type *player_ptr)
2873 {
2874     auto sniper_data = PlayerClass(player_ptr).get_specific_data<sniper_data_type>();
2875     auto sniper_concent = sniper_data ? sniper_data->concent : 0;
2876     return player_ptr->tim_esp || music_singing(player_ptr, MUSIC_MIND) || (sniper_concent >= CONCENT_TELE_THRESHOLD);
2877 }
2878
2879 bool is_tim_stealth(player_type *player_ptr)
2880 {
2881     return player_ptr->tim_stealth || music_singing(player_ptr, MUSIC_STEALTH);
2882 }
2883
2884 bool is_time_limit_esp(player_type *player_ptr)
2885 {
2886     auto sniper_data = PlayerClass(player_ptr).get_specific_data<sniper_data_type>();
2887     auto sniper_concent = sniper_data ? sniper_data->concent : 0;
2888     return player_ptr->tim_esp || music_singing(player_ptr, MUSIC_MIND) || (sniper_concent >= CONCENT_TELE_THRESHOLD);
2889 }
2890
2891 bool is_time_limit_stealth(player_type *player_ptr)
2892 {
2893     return player_ptr->tim_stealth || music_singing(player_ptr, MUSIC_STEALTH);
2894 }
2895
2896 /*!
2897  * @brief 口を使う継続的な処理を中断する
2898  * @param player_ptr プレイヤーへの参照ポインタ
2899  */
2900 void stop_mouth(player_type *player_ptr)
2901 {
2902     if (music_singing_any(player_ptr))
2903         stop_singing(player_ptr);
2904
2905     if (SpellHex(player_ptr).is_spelling_any()) {
2906         (void)SpellHex(player_ptr).stop_all_spells();
2907     }
2908 }
2909
2910 bool is_fast(player_type *player_ptr)
2911 {
2912     return player_ptr->fast || music_singing(player_ptr, MUSIC_SPEED) || music_singing(player_ptr, MUSIC_SHERO);
2913 }
2914
2915 bool is_invuln(player_type *player_ptr)
2916 {
2917     return player_ptr->invuln || music_singing(player_ptr, MUSIC_INVULN);
2918 }
2919
2920 bool is_hero(player_type *player_ptr)
2921 {
2922     return player_ptr->hero || music_singing(player_ptr, MUSIC_HERO) || music_singing(player_ptr, MUSIC_SHERO);
2923 }
2924
2925 bool is_shero(player_type *player_ptr)
2926 {
2927     return player_ptr->shero || player_ptr->pclass == PlayerClassType::BERSERKER;
2928 }
2929
2930 bool is_echizen(player_type *player_ptr)
2931 {
2932     return (player_ptr->ppersonality == PERSONALITY_COMBAT) || (player_ptr->inventory_list[INVEN_BOW].name1 == ART_CRIMSON);
2933 }
2934
2935 bool is_chargeman(player_type *player_ptr)
2936 {
2937     return player_ptr->ppersonality == PERSONALITY_CHARGEMAN;
2938 }
2939
2940 WEIGHT calc_weapon_weight_limit(player_type *player_ptr)
2941 {
2942     WEIGHT weight = adj_str_hold[player_ptr->stat_index[A_STR]];
2943
2944     if (has_two_handed_weapons(player_ptr))
2945         weight *= 2;
2946
2947     return weight;
2948 }
2949
2950 WEIGHT calc_bow_weight_limit(player_type *player_ptr)
2951 {
2952     WEIGHT weight = adj_str_hold[player_ptr->stat_index[A_STR]];
2953
2954     return weight;
2955 }
2956
2957 static player_hand main_attack_hand(player_type *player_ptr)
2958 {
2959     switch (player_melee_type(player_ptr)) {
2960     case MELEE_TYPE_BAREHAND_TWO:
2961         return PLAYER_HAND_MAIN;
2962     case MELEE_TYPE_BAREHAND_MAIN:
2963         return PLAYER_HAND_MAIN;
2964     case MELEE_TYPE_BAREHAND_SUB:
2965         return PLAYER_HAND_SUB;
2966     case MELEE_TYPE_WEAPON_MAIN:
2967         return PLAYER_HAND_MAIN;
2968     case MELEE_TYPE_WEAPON_SUB:
2969         return PLAYER_HAND_SUB;
2970     case MELEE_TYPE_WEAPON_TWOHAND:
2971         return has_melee_weapon(player_ptr, INVEN_MAIN_HAND) ? PLAYER_HAND_MAIN : PLAYER_HAND_SUB;
2972     case MELEE_TYPE_WEAPON_DOUBLE:
2973         return PLAYER_HAND_MAIN;
2974     case MELEE_TYPE_SHIELD_DOUBLE:
2975         return PLAYER_HAND_MAIN;
2976     }
2977     return PLAYER_HAND_MAIN;
2978 }