X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=src%2Fmspell%2Fmspell-damage-calculator.cpp;h=e2d55583d549031d56518a75f603d32dd4bfb552;hb=b32b7ffcbeb3b0fb5d1e09eccd9079691f38d1b1;hp=4956d7ef86bde17495da65896f2012d506cf39e0;hpb=99c48e7cf8dd6983ff23b72e593a5f638f2b82ec;p=hengbandforosx%2Fhengbandosx.git

diff --git a/src/mspell/mspell-damage-calculator.cpp b/src/mspell/mspell-damage-calculator.cpp
index 4956d7ef8..e2d55583d 100644
--- a/src/mspell/mspell-damage-calculator.cpp
+++ b/src/mspell/mspell-damage-calculator.cpp
@@ -1,11 +1,17 @@
 #include "mspell/mspell-damage-calculator.h"
-#include "inventory/inventory-slot-types.h"
 #include "game-option/birth-options.h"
+#include "inventory/inventory-slot-types.h"
 #include "monster-race/monster-race.h"
+#include "monster-race/race-ability-flags.h"
 #include "monster-race/race-flags2.h"
 #include "monster/monster-status.h"
+#include "player-info/equipment-info.h"
 #include "system/floor-type-definition.h"
+#include "system/monster-race-definition.h"
+#include "system/monster-type-definition.h"
 #include "system/object-type-definition.h"
+#include "system/player-type-definition.h"
+#include "util/bit-flags-calculator.h"
 
 /*!
  * @brief モンスターの使う呪文の威力を決定する /
@@ -48,7 +54,7 @@ static HIT_POINT monspell_damage_roll(HIT_POINT dam, int dice_num, int dice_side
 
 /*!
  * @brief モンスターの使う呪文の威力を返す /
- * @param target_ptr プレーヤーへの参照ポインタ (破滅の手用)
+ * @param player_ptr プレイヤーへの参照ポインタ (破滅の手用)
  * @param SPELL_NUM 呪文番号
  * @param hp 呪文を唱えるモンスターの体力
  * @param rlev 呪文を唱えるモンスターのレベル
@@ -60,98 +66,98 @@ static HIT_POINT monspell_damage_roll(HIT_POINT dam, int dice_num, int dice_side
  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  */
 static HIT_POINT monspell_damage_base(
-    player_type *target_ptr, monster_spell_type ms_type, int hp, int rlev, bool powerful, int shoot_dd, int shoot_ds, int shoot_base, int TYPE)
+    PlayerType *player_ptr, MonsterAbilityType ms_type, int hp, int rlev, bool powerful, int shoot_dd, int shoot_ds, int shoot_base, int TYPE)
 {
     HIT_POINT dam = 0, dice_num = 0, dice_side = 0, mult = 1, div = 1;
 
     switch (ms_type) {
-    case MS_SHRIEK:
+    case MonsterAbilityType::SHRIEK:
         return -1;
-    case MS_XXX1:
+    case MonsterAbilityType::XXX1:
         return -1;
-    case MS_DISPEL:
+    case MonsterAbilityType::DISPEL:
         return -1;
-    case MS_ROCKET:
+    case MonsterAbilityType::ROCKET:
         dam = (hp / 4) > 800 ? 800 : (hp / 4);
         break;
-    case MS_SHOOT:
+    case MonsterAbilityType::SHOOT:
         dice_num = shoot_dd;
         dice_side = shoot_ds;
         dam = shoot_base;
         break;
-    case MS_XXX2:
+    case MonsterAbilityType::XXX2:
         return -1;
-    case MS_XXX3:
+    case MonsterAbilityType::XXX3:
         return -1;
-    case MS_XXX4:
+    case MonsterAbilityType::XXX4:
         return -1;
 
-    case MS_BR_ACID:
-    case MS_BR_ELEC:
-    case MS_BR_FIRE:
-    case MS_BR_COLD:
+    case MonsterAbilityType::BR_ACID:
+    case MonsterAbilityType::BR_ELEC:
+    case MonsterAbilityType::BR_FIRE:
+    case MonsterAbilityType::BR_COLD:
         dam = ((hp / 3) > 1600 ? 1600 : (hp / 3));
         break;
-    case MS_BR_POIS:
+    case MonsterAbilityType::BR_POIS:
         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
         break;
-    case MS_BR_NETHER:
+    case MonsterAbilityType::BR_NETH:
         dam = ((hp / 6) > 550 ? 550 : (hp / 6));
         break;
-    case MS_BR_LITE:
-    case MS_BR_DARK:
+    case MonsterAbilityType::BR_LITE:
+    case MonsterAbilityType::BR_DARK:
         dam = ((hp / 6) > 400 ? 400 : (hp / 6));
         break;
-    case MS_BR_CONF:
-    case MS_BR_SOUND:
+    case MonsterAbilityType::BR_CONF:
+    case MonsterAbilityType::BR_SOUN:
         dam = ((hp / 6) > 450 ? 450 : (hp / 6));
         break;
-    case MS_BR_CHAOS:
+    case MonsterAbilityType::BR_CHAO:
         dam = ((hp / 6) > 600 ? 600 : (hp / 6));
         break;
-    case MS_BR_DISEN:
+    case MonsterAbilityType::BR_DISE:
         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
         break;
-    case MS_BR_NEXUS:
+    case MonsterAbilityType::BR_NEXU:
         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
         break;
-    case MS_BR_TIME:
+    case MonsterAbilityType::BR_TIME:
         dam = ((hp / 3) > 150 ? 150 : (hp / 3));
         break;
-    case MS_BR_INERTIA:
-    case MS_BR_GRAVITY:
+    case MonsterAbilityType::BR_INER:
+    case MonsterAbilityType::BR_GRAV:
         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
         break;
-    case MS_BR_SHARDS:
+    case MonsterAbilityType::BR_SHAR:
         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
         break;
-    case MS_BR_PLASMA:
+    case MonsterAbilityType::BR_PLAS:
         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
         break;
-    case MS_BR_FORCE:
+    case MonsterAbilityType::BR_FORC:
         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
         break;
-    case MS_BR_MANA:
+    case MonsterAbilityType::BR_MANA:
         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
         break;
-    case MS_BALL_NUKE:
+    case MonsterAbilityType::BA_NUKE:
         mult = powerful ? 2 : 1;
         dam = rlev * (mult / div);
         dice_num = 10;
         dice_side = 6;
         break;
-    case MS_BR_NUKE:
+    case MonsterAbilityType::BR_NUKE:
         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
         break;
-    case MS_BALL_CHAOS:
+    case MonsterAbilityType::BA_CHAO:
         dam = (powerful ? (rlev * 3) : (rlev * 2));
         dice_num = 10;
         dice_side = 10;
         break;
-    case MS_BR_DISI:
+    case MonsterAbilityType::BR_DISI:
         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
         break;
-    case MS_BALL_ACID:
+    case MonsterAbilityType::BA_ACID:
         if (powerful) {
             dam = (rlev * 4) + 50;
             dice_num = 10;
@@ -163,7 +169,7 @@ static HIT_POINT monspell_damage_base(
         }
 
         break;
-    case MS_BALL_ELEC:
+    case MonsterAbilityType::BA_ELEC:
         if (powerful) {
             dam = (rlev * 4) + 50;
             dice_num = 10;
@@ -175,7 +181,7 @@ static HIT_POINT monspell_damage_base(
         }
 
         break;
-    case MS_BALL_FIRE:
+    case MonsterAbilityType::BA_FIRE:
         if (powerful) {
             dam = (rlev * 4) + 50;
             dice_num = 10;
@@ -187,7 +193,7 @@ static HIT_POINT monspell_damage_base(
         }
 
         break;
-    case MS_BALL_COLD:
+    case MonsterAbilityType::BA_COLD:
         if (powerful) {
             dam = (rlev * 4) + 50;
             dice_num = 10;
@@ -199,201 +205,203 @@ static HIT_POINT monspell_damage_base(
         }
 
         break;
-    case MS_BALL_POIS:
+    case MonsterAbilityType::BA_POIS:
         mult = powerful ? 2 : 1;
         dice_num = 12;
         dice_side = 2;
         break;
-    case MS_BALL_NETHER:
+    case MonsterAbilityType::BA_NETH:
         dam = 50 + rlev * (powerful ? 2 : 1);
         dice_num = 10;
         dice_side = 10;
         break;
-    case MS_BALL_WATER:
+    case MonsterAbilityType::BA_WATE:
         dam = 50;
         dice_num = 1;
         dice_side = powerful ? (rlev * 3) : (rlev * 2);
         break;
-    case MS_BALL_MANA:
-    case MS_BALL_DARK:
+    case MonsterAbilityType::BA_MANA:
+    case MonsterAbilityType::BA_DARK:
         dam = (rlev * 4) + 50;
         dice_num = 10;
         dice_side = 10;
         break;
-    case MS_DRAIN_MANA:
+    case MonsterAbilityType::DRAIN_MANA:
         dam = rlev;
         div = 1;
         dice_num = 1;
         dice_side = rlev;
         break;
-    case MS_MIND_BLAST:
+    case MonsterAbilityType::MIND_BLAST:
         dice_num = 7;
         dice_side = 7;
         break;
-    case MS_BRAIN_SMASH:
+    case MonsterAbilityType::BRAIN_SMASH:
         dice_num = 12;
         dice_side = 12;
         break;
-    case MS_CAUSE_1:
+    case MonsterAbilityType::CAUSE_1:
         dice_num = 3;
         dice_side = 8;
         break;
-    case MS_CAUSE_2:
+    case MonsterAbilityType::CAUSE_2:
         dice_num = 8;
         dice_side = 8;
         break;
-    case MS_CAUSE_3:
+    case MonsterAbilityType::CAUSE_3:
         dice_num = 10;
         dice_side = 15;
         break;
-    case MS_CAUSE_4:
+    case MonsterAbilityType::CAUSE_4:
         dice_num = 15;
         dice_side = 15;
         break;
-    case MS_BOLT_ACID:
+    case MonsterAbilityType::BO_ACID:
         mult = powerful ? 2 : 1;
         dam = rlev / 3 * (mult / div);
         dice_num = 7;
         dice_side = 8;
         break;
-    case MS_BOLT_ELEC:
+    case MonsterAbilityType::BO_ELEC:
         mult = powerful ? 2 : 1;
         dam = rlev / 3 * (mult / div);
         dice_num = 4;
         dice_side = 8;
         break;
-    case MS_BOLT_FIRE:
+    case MonsterAbilityType::BO_FIRE:
         mult = powerful ? 2 : 1;
         dam = rlev / 3 * (mult / div);
         dice_num = 9;
         dice_side = 8;
         break;
-    case MS_BOLT_COLD:
+    case MonsterAbilityType::BO_COLD:
         mult = powerful ? 2 : 1;
         dam = rlev / 3 * (mult / div);
         dice_num = 6;
         dice_side = 8;
         break;
-    case MS_STARBURST:
+    case MonsterAbilityType::BA_LITE:
         dam = (rlev * 4) + 50;
         dice_num = 10;
         dice_side = 10;
         break;
-    case MS_BOLT_NETHER:
+    case MonsterAbilityType::BO_NETH:
         dam = 30 + (rlev * 4) / (powerful ? 2 : 3);
         dice_num = 5;
         dice_side = 5;
         break;
-    case MS_BOLT_WATER:
+    case MonsterAbilityType::BO_WATE:
         dam = (rlev * 3 / (powerful ? 2 : 3));
         dice_num = 10;
         dice_side = 10;
         break;
-    case MS_BOLT_MANA:
+    case MonsterAbilityType::BO_MANA:
         dam = 50;
         dice_num = 1;
         dice_side = rlev * 7 / 2;
         break;
-    case MS_BOLT_PLASMA:
+    case MonsterAbilityType::BO_PLAS:
         dam = 10 + (rlev * 3 / (powerful ? 2 : 3));
         dice_num = 8;
         dice_side = 7;
         break;
-    case MS_BOLT_ICE:
+    case MonsterAbilityType::BO_ICEE:
         dam = (rlev * 3 / (powerful ? 2 : 3));
         dice_num = 6;
         dice_side = 6;
         break;
-    case MS_MAGIC_MISSILE:
+    case MonsterAbilityType::MISSILE:
         dam = (rlev / 3);
         dice_num = 2;
         dice_side = 6;
         break;
-    case MS_SCARE:
+    case MonsterAbilityType::SCARE:
         return -1;
-    case MS_BLIND:
+    case MonsterAbilityType::BLIND:
         return -1;
-    case MS_CONF:
+    case MonsterAbilityType::CONF:
         return -1;
-    case MS_SLOW:
+    case MonsterAbilityType::SLOW:
         return -1;
-    case MS_SLEEP:
+    case MonsterAbilityType::HOLD:
         return -1;
-    case MS_SPEED:
+    case MonsterAbilityType::HASTE:
         return -1;
 
-    case MS_HAND_DOOM:
-        mult = target_ptr->chp;
+    case MonsterAbilityType::HAND_DOOM:
+        mult = player_ptr->chp;
         div = 100;
         dam = 40 * (mult / div);
         dice_num = 1;
         dice_side = 20;
         break;
 
-    case MS_HEAL:
+    case MonsterAbilityType::HEAL:
         return -1;
-    case MS_INVULNER:
+    case MonsterAbilityType::INVULNER:
         return -1;
-    case MS_BLINK:
+    case MonsterAbilityType::BLINK:
         return -1;
-    case MS_TELEPORT:
+    case MonsterAbilityType::TPORT:
         return -1;
-    case MS_WORLD:
+    case MonsterAbilityType::WORLD:
         return -1;
-    case MS_SPECIAL:
+    case MonsterAbilityType::SPECIAL:
         return -1;
-    case MS_TELE_TO:
+    case MonsterAbilityType::TELE_TO:
         return -1;
-    case MS_TELE_AWAY:
+    case MonsterAbilityType::TELE_AWAY:
         return -1;
-    case MS_TELE_LEVEL:
+    case MonsterAbilityType::TELE_LEVEL:
         return -1;
 
-    case MS_PSY_SPEAR:
+    case MonsterAbilityType::PSY_SPEAR:
         dam = powerful ? 150 : 100;
         dice_num = 1;
         dice_side = powerful ? (rlev * 2) : (rlev * 3 / 2);
         break;
 
-    case MS_DARKNESS:
+    case MonsterAbilityType::DARKNESS:
+        return -1;
+    case MonsterAbilityType::TRAPS:
         return -1;
-    case MS_MAKE_TRAP:
+    case MonsterAbilityType::FORGET:
         return -1;
-    case MS_FORGET:
+    case MonsterAbilityType::RAISE_DEAD:
         return -1;
-    case MS_RAISE_DEAD:
+    case MonsterAbilityType::S_KIN:
         return -1;
-    case MS_S_KIN:
+    case MonsterAbilityType::S_CYBER:
         return -1;
-    case MS_S_CYBER:
+    case MonsterAbilityType::S_MONSTER:
         return -1;
-    case MS_S_MONSTER:
+    case MonsterAbilityType::S_MONSTERS:
         return -1;
-    case MS_S_MONSTERS:
+    case MonsterAbilityType::S_ANT:
         return -1;
-    case MS_S_ANT:
+    case MonsterAbilityType::S_SPIDER:
         return -1;
-    case MS_S_SPIDER:
+    case MonsterAbilityType::S_HOUND:
         return -1;
-    case MS_S_HOUND:
+    case MonsterAbilityType::S_HYDRA:
         return -1;
-    case MS_S_HYDRA:
+    case MonsterAbilityType::S_ANGEL:
         return -1;
-    case MS_S_ANGEL:
+    case MonsterAbilityType::S_DEMON:
         return -1;
-    case MS_S_DEMON:
+    case MonsterAbilityType::S_UNDEAD:
         return -1;
-    case MS_S_UNDEAD:
+    case MonsterAbilityType::S_DRAGON:
         return -1;
-    case MS_S_DRAGON:
+    case MonsterAbilityType::S_HI_UNDEAD:
         return -1;
-    case MS_S_HI_UNDEAD:
+    case MonsterAbilityType::S_HI_DRAGON:
         return -1;
-    case MS_S_HI_DRAGON:
+    case MonsterAbilityType::S_AMBERITES:
         return -1;
-    case MS_S_AMBERITE:
+    case MonsterAbilityType::S_UNIQUE:
         return -1;
-    case MS_S_UNIQUE:
+    case MonsterAbilityType::MAX:
         return -1;
     }
 
@@ -405,7 +413,6 @@ static HIT_POINT monspell_damage_base(
  * @param r_ptr モンスター種族への参照ポインタ
  * @param dd ダイス数への参照ポインタ
  * @param ds ダイス面への参照ポインタ
- * @return なし
  */
 void monspell_shoot_dice(monster_race *r_ptr, int *dd, int *ds)
 {
@@ -413,10 +420,10 @@ void monspell_shoot_dice(monster_race *r_ptr, int *dd, int *ds)
     int n = 0; /* Number of blows */
     const int max_blows = 4;
     for (int m = 0; m < max_blows; m++) {
-        if (r_ptr->blow[m].method != RBM_NONE)
+        if (r_ptr->blow[m].method != RaceBlowMethodType::NONE)
             n++; /* Count blows */
 
-        if (r_ptr->blow[m].method == RBM_SHOOT) {
+        if (r_ptr->blow[m].method == RaceBlowMethodType::SHOOT) {
             p = m; /* Remember position */
             break;
         }
@@ -437,15 +444,15 @@ void monspell_shoot_dice(monster_race *r_ptr, int *dd, int *ds)
 
 /*!
  * @brief モンスターの使う呪文の威力を返す /
- * @param target_ptr プレーヤーへの参照ポインタ
+ * @param player_ptr プレイヤーへの参照ポインタ
  * @param ms_type 呪文番号
  * @param m_idx 呪文を唱えるモンスターID
  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  */
-HIT_POINT monspell_damage(player_type *target_ptr, monster_spell_type ms_type, MONSTER_IDX m_idx, int TYPE)
+HIT_POINT monspell_damage(PlayerType *player_ptr, MonsterAbilityType ms_type, MONSTER_IDX m_idx, int TYPE)
 {
-    floor_type *floor_ptr = target_ptr->current_floor_ptr;
+    floor_type *floor_ptr = player_ptr->current_floor_ptr;
     monster_type *m_ptr = &floor_ptr->m_list[m_idx];
     monster_race *r_ptr = &r_info[m_ptr->r_idx];
     DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
@@ -453,47 +460,47 @@ HIT_POINT monspell_damage(player_type *target_ptr, monster_spell_type ms_type, M
     int shoot_dd, shoot_ds;
 
     monspell_shoot_dice(r_ptr, &shoot_dd, &shoot_ds);
-    return monspell_damage_base(target_ptr, ms_type, hp, rlev, monster_is_powerful(floor_ptr, m_idx), shoot_dd, shoot_ds, 0, TYPE);
+    return monspell_damage_base(player_ptr, ms_type, hp, rlev, monster_is_powerful(floor_ptr, m_idx), shoot_dd, shoot_ds, 0, TYPE);
 }
 
 /*!
  * @brief モンスターの使う所属としての呪文の威力を返す /
- * @param target_ptr プレーヤーへの参照ポインタ
+ * @param player_ptr プレイヤーへの参照ポインタ
  * @param ms_type 呪文番号
  * @param r_idx 呪文を唱えるモンスターの種族ID
  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  */
-HIT_POINT monspell_race_damage(player_type *target_ptr, monster_spell_type ms_type, MONRACE_IDX r_idx, int TYPE)
+HIT_POINT monspell_race_damage(PlayerType *player_ptr, MonsterAbilityType ms_type, MONRACE_IDX r_idx, int TYPE)
 {
     monster_race *r_ptr = &r_info[r_idx];
     DEPTH rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
-    bool powerful = r_ptr->flags2 & RF2_POWERFUL ? TRUE : FALSE;
+    bool powerful = any_bits(r_ptr->flags2, RF2_POWERFUL);
     HIT_POINT hp = r_ptr->hdice * (ironman_nightmare ? 2 : 1) * r_ptr->hside;
     int shoot_dd, shoot_ds;
 
     monspell_shoot_dice(r_ptr, &shoot_dd, &shoot_ds);
-    return monspell_damage_base(target_ptr, ms_type, MIN(30000, hp), rlev, powerful, shoot_dd, shoot_ds, 0, TYPE);
+    return monspell_damage_base(player_ptr, ms_type, std::min(MONSTER_MAXHP, hp), rlev, powerful, shoot_dd, shoot_ds, 0, TYPE);
 }
 
 /*!
  * @brief 青魔導師の使う呪文の威力を返す /
- * @param target_ptr プレーヤーへの参照ポインタ
+ * @param player_ptr プレイヤーへの参照ポインタ
  * @param SPELL_NUM 呪文番号
  * @param plev 使用するレベル。2倍して扱う。
  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  */
-HIT_POINT monspell_bluemage_damage(player_type *target_ptr, monster_spell_type ms_type, PLAYER_LEVEL plev, int TYPE)
+HIT_POINT monspell_bluemage_damage(PlayerType *player_ptr, MonsterAbilityType ms_type, PLAYER_LEVEL plev, int TYPE)
 {
-    int hp = target_ptr->chp;
+    int hp = player_ptr->chp;
     int shoot_dd = 1, shoot_ds = 1, shoot_base = 0;
-    object_type *o_ptr = NULL;
+    object_type *o_ptr = nullptr;
 
-    if (has_melee_weapon(target_ptr, INVEN_MAIN_HAND))
-        o_ptr = &target_ptr->inventory_list[INVEN_MAIN_HAND];
-    else if (has_melee_weapon(target_ptr, INVEN_SUB_HAND))
-        o_ptr = &target_ptr->inventory_list[INVEN_SUB_HAND];
+    if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND))
+        o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND];
+    else if (has_melee_weapon(player_ptr, INVEN_SUB_HAND))
+        o_ptr = &player_ptr->inventory_list[INVEN_SUB_HAND];
 
     if (o_ptr) {
         shoot_dd = o_ptr->dd;
@@ -501,5 +508,5 @@ HIT_POINT monspell_bluemage_damage(player_type *target_ptr, monster_spell_type m
         shoot_base = o_ptr->to_d;
     }
 
-    return monspell_damage_base(target_ptr, ms_type, hp, plev * 2, FALSE, shoot_dd, shoot_ds, shoot_base, TYPE);
+    return monspell_damage_base(player_ptr, ms_type, hp, plev * 2, false, shoot_dd, shoot_ds, shoot_base, TYPE);
 }