src/hpmp/hp-mp-regenerator.cpp

   1 #include "hpmp/hp-mp-regenerator.h"
   2 #include "cmd-item/cmd-magiceat.h"
   3 #include "core/window-redrawer.h"
   4 #include "inventory/inventory-slot-types.h"
   5 #include "monster-race/monster-race.h"
   6 #include "monster-race/race-flags2.h"
   7 #include "monster/monster-status.h"
   8 #include "player-base/player-class.h"
   9 #include "player-info/magic-eater-data-type.h"
  10 #include "player-info/samurai-data-type.h"
  11 #include "player/attack-defense-types.h"
  12 #include "player/player-status-table.h"
  13 #include "player/special-defense-types.h"
  14 #include "system/floor-type-definition.h"
  15 #include "system/item-entity.h"
  16 #include "system/monster-entity.h"
  17 #include "system/monster-race-info.h"
  18 #include "system/player-type-definition.h"
  19 #include "system/redrawing-flags-updater.h"
  20
  21 /*!<広域マップ移動時の自然回復処理カウンタ（広域マップ1マス毎に20回処理を基本とする）*/
  22 int wild_regen = 20;
  23
  24 /*!
  25  * @brief プレイヤーのHP自然回復処理 / Regenerate hit points -RAK-
  26  * @param percent 回復比率
  27  */
  28 void regenhp(PlayerType *player_ptr, int percent)
  29 {
  30     if (PlayerClass(player_ptr).samurai_stance_is(SamuraiStanceType::KOUKIJIN)) {
  31         return;
  32     }
  33     if (player_ptr->action == ACTION_HAYAGAKE) {
  34         return;
  35     }
  36
  37     int old_chp = player_ptr->chp;
  38
  39     /*
  40      * Extract the new hitpoints
  41      *
  42      * 'percent' is the Regen factor in unit (1/2^16)
  43      */
  44     int new_chp = 0;
  45     uint32_t new_chp_frac = (player_ptr->mhp * percent + PY_REGEN_HPBASE);
  46     s64b_lshift(&new_chp, &new_chp_frac, 16);
  47     s64b_add(&(player_ptr->chp), &(player_ptr->chp_frac), new_chp, new_chp_frac);
  48     if (0 < s64b_cmp(player_ptr->chp, player_ptr->chp_frac, player_ptr->mhp, 0)) {
  49         player_ptr->chp = player_ptr->mhp;
  50         player_ptr->chp_frac = 0;
  51     }
  52
  53     if (old_chp != player_ptr->chp) {
  54         auto &rfu = RedrawingFlagsUpdater::get_instance();
  55         rfu.set_flag(MainWindowRedrawingFlag::HP);
  56         rfu.set_flag(SubWindowRedrawingFlag::PLAYER);
  57         wild_regen = 20;
  58     }
  59 }
  60
  61 /*!
  62  * @brief プレイヤーのMP自然回復処理(regen_magic()のサブセット) / Regenerate mana points
  63  * @param upkeep_factor ペット維持によるMPコスト量
  64  * @param regen_amount 回復量
  65  */
  66 void regenmana(PlayerType *player_ptr, MANA_POINT upkeep_factor, MANA_POINT regen_amount)
  67 {
  68     MANA_POINT old_csp = player_ptr->csp;
  69     int32_t regen_rate = regen_amount * 100 - upkeep_factor * PY_REGEN_NORMAL;
  70
  71     /*
  72      * Excess mana will decay 32 times faster than normal
  73      * regeneration rate.
  74      */
  75     if (player_ptr->csp > player_ptr->msp) {
  76         int32_t decay = 0;
  77         uint32_t decay_frac = (player_ptr->msp * 32 * PY_REGEN_NORMAL + PY_REGEN_MNBASE);
  78         s64b_lshift(&decay, &decay_frac, 16);
  79         s64b_sub(&(player_ptr->csp), &(player_ptr->csp_frac), decay, decay_frac);
  80         if (player_ptr->csp < player_ptr->msp) {
  81             player_ptr->csp = player_ptr->msp;
  82             player_ptr->csp_frac = 0;
  83         }
  84     }
  85
  86     /* Regenerating mana (unless the player has excess mana) */
  87     else if (regen_rate > 0) {
  88         MANA_POINT new_mana = 0;
  89         uint32_t new_mana_frac = (player_ptr->msp * regen_rate / 100 + PY_REGEN_MNBASE);
  90         s64b_lshift(&new_mana, &new_mana_frac, 16);
  91         s64b_add(&(player_ptr->csp), &(player_ptr->csp_frac), new_mana, new_mana_frac);
  92         if (player_ptr->csp >= player_ptr->msp) {
  93             player_ptr->csp = player_ptr->msp;
  94             player_ptr->csp_frac = 0;
  95         }
  96     }
  97
  98     /* Reduce mana (even when the player has excess mana) */
  99     if (regen_rate < 0) {
 100         int32_t reduce_mana = 0;
 101         uint32_t reduce_mana_frac = (player_ptr->msp * (-1) * regen_rate / 100 + PY_REGEN_MNBASE);
 102         s64b_lshift(&reduce_mana, &reduce_mana_frac, 16);
 103         s64b_sub(&(player_ptr->csp), &(player_ptr->csp_frac), reduce_mana, reduce_mana_frac);
 104         if (player_ptr->csp < 0) {
 105             player_ptr->csp = 0;
 106             player_ptr->csp_frac = 0;
 107         }
 108     }
 109
 110     if (old_csp != player_ptr->csp) {
 111         auto &rfu = RedrawingFlagsUpdater::get_instance();
 112         rfu.set_flag(MainWindowRedrawingFlag::MP);
 113         static constexpr auto flags = {
 114             SubWindowRedrawingFlag::PLAYER,
 115             SubWindowRedrawingFlag::SPELL,
 116         };
 117         rfu.set_flags(flags);
 118         wild_regen = 20;
 119     }
 120 }
 121
 122 /*!
 123  * @brief 取り込んだ魔道具の自然回復処理 / Regenerate magic regen_amount: PY_REGEN_NORMAL * 2 (if resting) * 2 (if having regenarate)
 124  * @param regen_amount 回復量
 125  */
 126 void regenmagic(PlayerType *player_ptr, int regen_amount)
 127 {
 128     auto magic_eater_data = PlayerClass(player_ptr).get_specific_data<magic_eater_data_type>();
 129     if (!magic_eater_data) {
 130         return;
 131     }
 132
 133     const int dev = 30;
 134     const int mult = (dev + adj_mag_mana[player_ptr->stat_index[A_INT]]); /* x1 to x2 speed bonus for recharging */
 135
 136     for (auto tval : { ItemKindType::STAFF, ItemKindType::WAND }) {
 137         for (auto &item : magic_eater_data->get_item_group(tval)) {
 138             const int maximum_charge = item.count * EATER_CHARGE;
 139             if (item.count == 0 || item.charge == maximum_charge) {
 140                 continue;
 141             }
 142
 143             /* Increase remaining charge number like float value */
 144             auto new_mana = (regen_amount * mult * (item.count + 13)) / (dev * 8);
 145             item.charge += new_mana;
 146
 147             /* Check maximum charge */
 148             item.charge = std::min(item.charge, maximum_charge);
 149         }
 150     }
 151
 152     for (auto &item : magic_eater_data->get_item_group(ItemKindType::ROD)) {
 153         if (item.count == 0 || item.charge == 0) {
 154             continue;
 155         }
 156
 157         /* Decrease remaining period for charging */
 158         auto new_mana = (regen_amount * mult * (item.count + 10) * EATER_ROD_CHARGE) / (dev * 16 * PY_REGEN_NORMAL);
 159         item.charge -= new_mana;
 160
 161         /* Check minimum remaining period for charging */
 162         item.charge = std::max(item.charge, 0);
 163     }
 164
 165     wild_regen = 20;
 166 }
 167
 168 /*!
 169  * @brief 100ゲームターン毎のモンスターのHP自然回復処理 / Regenerate the monsters (once per 100 game turns)
 170  * @param player_ptr プレイヤーへの参照ポインタ
 171  * @note Should probably be done during monster turns.
 172  */
 173 void regenerate_monsters(PlayerType *player_ptr)
 174 {
 175     for (int i = 1; i < player_ptr->current_floor_ptr->m_max; i++) {
 176         auto *m_ptr = &player_ptr->current_floor_ptr->m_list[i];
 177         auto *r_ptr = &monraces_info[m_ptr->r_idx];
 178
 179         if (!m_ptr->is_valid()) {
 180             continue;
 181         }
 182
 183         if (m_ptr->hp < m_ptr->maxhp) {
 184             int frac = m_ptr->maxhp / 100;
 185             if (!frac) {
 186                 if (one_in_(2)) {
 187                     frac = 1;
 188                 }
 189             }
 190
 191             if (r_ptr->flags2 & RF2_REGENERATE) {
 192                 frac *= 2;
 193             }
 194
 195             m_ptr->hp += frac;
 196             if (m_ptr->hp > m_ptr->maxhp) {
 197                 m_ptr->hp = m_ptr->maxhp;
 198             }
 199
 200             auto &rfu = RedrawingFlagsUpdater::get_instance();
 201             if (player_ptr->health_who == i) {
 202                 rfu.set_flag(MainWindowRedrawingFlag::HEALTH);
 203             }
 204             if (player_ptr->riding == i) {
 205                 rfu.set_flag(MainWindowRedrawingFlag::UHEALTH);
 206             }
 207         }
 208     }
 209 }
 210
 211 /*!
 212  * @brief 30ゲームターン毎のボール中モンスターのHP自然回復処理 / Regenerate the captured monsters (once per 30 game turns)
 213  * @param player_ptr プレイヤーへの参照ポインタ
 214  * @note Should probably be done during monster turns.
 215  */
 216 void regenerate_captured_monsters(PlayerType *player_ptr)
 217 {
 218     bool heal = false;
 219     for (int i = 0; i < INVEN_TOTAL; i++) {
 220         auto *o_ptr = &player_ptr->inventory_list[i];
 221         if (!o_ptr->is_valid()) {
 222             continue;
 223         }
 224         if (o_ptr->bi_key.tval() != ItemKindType::CAPTURE) {
 225             continue;
 226         }
 227         if (!o_ptr->pval) {
 228             continue;
 229         }
 230
 231         heal = true;
 232         const auto r_idx = i2enum<MonsterRaceId>(o_ptr->pval);
 233         const auto *r_ptr = &monraces_info[r_idx];
 234         if (o_ptr->captured_monster_current_hp < o_ptr->captured_monster_max_hp) {
 235             short frac = o_ptr->captured_monster_max_hp / 100;
 236             if (!frac) {
 237                 if (one_in_(2)) {
 238                     frac = 1;
 239                 }
 240             }
 241
 242             if (r_ptr->flags2 & RF2_REGENERATE) {
 243                 frac *= 2;
 244             }
 245
 246             o_ptr->captured_monster_current_hp += frac;
 247             if (o_ptr->captured_monster_current_hp > o_ptr->captured_monster_max_hp) {
 248                 o_ptr->captured_monster_current_hp = o_ptr->captured_monster_max_hp;
 249             }
 250         }
 251     }
 252
 253     if (heal) {
 254         RedrawingFlagsUpdater::get_instance().set_flag(StatusRecalculatingFlag::COMBINATION);
 255
 256         /*!
 257          * @todo FIXME 広域マップ移動で1歩毎に何度も再描画されて重くなる.
 258          * 現在はボール中モンスターのHP回復でボールの表示は変わらないためコメントアウトする.
 259          */
 260         // rfu.set_flag(SubWindowRedrawingFlag::INVENTORY);
 261         // rfu.set_flag(SubWindowRedrawingFlag::EQUIPMENT);
 262         wild_regen = 20;
 263     }
 264 }