src/mspell/mspell-damage-calculator.cpp

   1 #include "mspell/mspell-damage-calculator.h"
   2 #include "game-option/birth-options.h"
   3 #include "inventory/inventory-slot-types.h"
   4 #include "monster-race/monster-race.h"
   5 #include "monster-race/race-ability-flags.h"
   6 #include "monster-race/race-flags2.h"
   7 #include "monster/monster-status.h"
   8 #include "player-info/equipment-info.h"
   9 #include "system/floor-type-definition.h"
  10 #include "system/monster-race-definition.h"
  11 #include "system/monster-type-definition.h"
  12 #include "system/object-type-definition.h"
  13 #include "system/player-type-definition.h"
  14 #include "util/bit-flags-calculator.h"
  15
  16 /*!
  17  * @brief モンスターの使う呪文の威力を決定する /
  18  * @param dam 定数値
  19  * @param dice_num ダイス数
  20  * @param dice_side ダイス面
  21  * @param mult ダイス倍率
  22  * @param div ダイス倍率
  23  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
  24  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  25  */
  26 static HIT_POINT monspell_damage_roll(HIT_POINT dam, int dice_num, int dice_side, int mult, int div, int TYPE)
  27 {
  28     switch (TYPE) {
  29     case DAM_MAX:
  30         dam += maxroll(dice_num, dice_side) * mult / div;
  31         break;
  32     case DAM_MIN:
  33         dam += dice_num * 1 * mult / div;
  34         break;
  35     case DAM_ROLL:
  36         dam += damroll(dice_num, dice_side) * mult / div;
  37         break;
  38     case DICE_NUM:
  39         return dice_num;
  40     case DICE_SIDE:
  41         return dice_side;
  42     case DICE_MULT:
  43         return mult;
  44     case DICE_DIV:
  45         return div;
  46     case BASE_DAM:
  47         return dam;
  48     }
  49
  50     if (dam < 1)
  51         dam = 1;
  52     return dam;
  53 }
  54
  55 /*!
  56  * @brief モンスターの使う呪文の威力を返す /
  57  * @param player_ptr プレイヤーへの参照ポインタ (破滅の手用)
  58  * @param SPELL_NUM 呪文番号
  59  * @param hp 呪文を唱えるモンスターの体力
  60  * @param rlev 呪文を唱えるモンスターのレベル
  61  * @param powerful 呪文を唱えるモンスターのpowerfulフラグ
  62  * @param shoot_dd 射撃のダイス数
  63  * @param shoot_ds 射撃のダイス面
  64  * @param shoot_base 射撃の固定威力値
  65  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
  66  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  67  */
  68 static HIT_POINT monspell_damage_base(
  69     PlayerType *player_ptr, MonsterAbilityType ms_type, int hp, int rlev, bool powerful, int shoot_dd, int shoot_ds, int shoot_base, int TYPE)
  70 {
  71     HIT_POINT dam = 0, dice_num = 0, dice_side = 0, mult = 1, div = 1;
  72
  73     switch (ms_type) {
  74     case MonsterAbilityType::SHRIEK:
  75         return -1;
  76     case MonsterAbilityType::XXX1:
  77         return -1;
  78     case MonsterAbilityType::DISPEL:
  79         return -1;
  80     case MonsterAbilityType::ROCKET:
  81         dam = (hp / 4) > 800 ? 800 : (hp / 4);
  82         break;
  83     case MonsterAbilityType::SHOOT:
  84         dice_num = shoot_dd;
  85         dice_side = shoot_ds;
  86         dam = shoot_base;
  87         break;
  88     case MonsterAbilityType::XXX2:
  89         return -1;
  90     case MonsterAbilityType::XXX3:
  91         return -1;
  92     case MonsterAbilityType::XXX4:
  93         return -1;
  94
  95     case MonsterAbilityType::BR_ACID:
  96     case MonsterAbilityType::BR_ELEC:
  97     case MonsterAbilityType::BR_FIRE:
  98     case MonsterAbilityType::BR_COLD:
  99         dam = ((hp / 3) > 1600 ? 1600 : (hp / 3));
 100         break;
 101     case MonsterAbilityType::BR_POIS:
 102         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
 103         break;
 104     case MonsterAbilityType::BR_NETH:
 105         dam = ((hp / 6) > 550 ? 550 : (hp / 6));
 106         break;
 107     case MonsterAbilityType::BR_LITE:
 108     case MonsterAbilityType::BR_DARK:
 109         dam = ((hp / 6) > 400 ? 400 : (hp / 6));
 110         break;
 111     case MonsterAbilityType::BR_CONF:
 112     case MonsterAbilityType::BR_SOUN:
 113         dam = ((hp / 6) > 450 ? 450 : (hp / 6));
 114         break;
 115     case MonsterAbilityType::BR_CHAO:
 116         dam = ((hp / 6) > 600 ? 600 : (hp / 6));
 117         break;
 118     case MonsterAbilityType::BR_DISE:
 119         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
 120         break;
 121     case MonsterAbilityType::BR_NEXU:
 122         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
 123         break;
 124     case MonsterAbilityType::BR_TIME:
 125         dam = ((hp / 3) > 150 ? 150 : (hp / 3));
 126         break;
 127     case MonsterAbilityType::BR_INER:
 128     case MonsterAbilityType::BR_GRAV:
 129         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
 130         break;
 131     case MonsterAbilityType::BR_SHAR:
 132         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
 133         break;
 134     case MonsterAbilityType::BR_PLAS:
 135         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
 136         break;
 137     case MonsterAbilityType::BR_FORC:
 138         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
 139         break;
 140     case MonsterAbilityType::BR_MANA:
 141         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
 142         break;
 143     case MonsterAbilityType::BA_NUKE:
 144         mult = powerful ? 2 : 1;
 145         dam = rlev * (mult / div);
 146         dice_num = 10;
 147         dice_side = 6;
 148         break;
 149     case MonsterAbilityType::BR_NUKE:
 150         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
 151         break;
 152     case MonsterAbilityType::BA_CHAO:
 153         dam = (powerful ? (rlev * 3) : (rlev * 2));
 154         dice_num = 10;
 155         dice_side = 10;
 156         break;
 157     case MonsterAbilityType::BR_DISI:
 158         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
 159         break;
 160     case MonsterAbilityType::BA_ACID:
 161         if (powerful) {
 162             dam = (rlev * 4) + 50;
 163             dice_num = 10;
 164             dice_side = 10;
 165         } else {
 166             dam = 15;
 167             dice_num = 1;
 168             dice_side = rlev * 3;
 169         }
 170
 171         break;
 172     case MonsterAbilityType::BA_ELEC:
 173         if (powerful) {
 174             dam = (rlev * 4) + 50;
 175             dice_num = 10;
 176             dice_side = 10;
 177         } else {
 178             dam = 8;
 179             dice_num = 1;
 180             dice_side = rlev * 3 / 2;
 181         }
 182
 183         break;
 184     case MonsterAbilityType::BA_FIRE:
 185         if (powerful) {
 186             dam = (rlev * 4) + 50;
 187             dice_num = 10;
 188             dice_side = 10;
 189         } else {
 190             dam = 10;
 191             dice_num = 1;
 192             dice_side = rlev * 7 / 2;
 193         }
 194
 195         break;
 196     case MonsterAbilityType::BA_COLD:
 197         if (powerful) {
 198             dam = (rlev * 4) + 50;
 199             dice_num = 10;
 200             dice_side = 10;
 201         } else {
 202             dam = 10;
 203             dice_num = 1;
 204             dice_side = rlev * 3 / 2;
 205         }
 206
 207         break;
 208     case MonsterAbilityType::BA_POIS:
 209         mult = powerful ? 2 : 1;
 210         dice_num = 12;
 211         dice_side = 2;
 212         break;
 213     case MonsterAbilityType::BA_NETH:
 214         dam = 50 + rlev * (powerful ? 2 : 1);
 215         dice_num = 10;
 216         dice_side = 10;
 217         break;
 218     case MonsterAbilityType::BA_WATE:
 219         dam = 50;
 220         dice_num = 1;
 221         dice_side = powerful ? (rlev * 3) : (rlev * 2);
 222         break;
 223     case MonsterAbilityType::BA_MANA:
 224     case MonsterAbilityType::BA_DARK:
 225         dam = (rlev * 4) + 50;
 226         dice_num = 10;
 227         dice_side = 10;
 228         break;
 229     case MonsterAbilityType::DRAIN_MANA:
 230         dam = rlev;
 231         div = 1;
 232         dice_num = 1;
 233         dice_side = rlev;
 234         break;
 235     case MonsterAbilityType::MIND_BLAST:
 236         dice_num = 7;
 237         dice_side = 7;
 238         break;
 239     case MonsterAbilityType::BRAIN_SMASH:
 240         dice_num = 12;
 241         dice_side = 12;
 242         break;
 243     case MonsterAbilityType::CAUSE_1:
 244         dice_num = 3;
 245         dice_side = 8;
 246         break;
 247     case MonsterAbilityType::CAUSE_2:
 248         dice_num = 8;
 249         dice_side = 8;
 250         break;
 251     case MonsterAbilityType::CAUSE_3:
 252         dice_num = 10;
 253         dice_side = 15;
 254         break;
 255     case MonsterAbilityType::CAUSE_4:
 256         dice_num = 15;
 257         dice_side = 15;
 258         break;
 259     case MonsterAbilityType::BO_ACID:
 260         mult = powerful ? 2 : 1;
 261         dam = rlev / 3 * (mult / div);
 262         dice_num = 7;
 263         dice_side = 8;
 264         break;
 265     case MonsterAbilityType::BO_ELEC:
 266         mult = powerful ? 2 : 1;
 267         dam = rlev / 3 * (mult / div);
 268         dice_num = 4;
 269         dice_side = 8;
 270         break;
 271     case MonsterAbilityType::BO_FIRE:
 272         mult = powerful ? 2 : 1;
 273         dam = rlev / 3 * (mult / div);
 274         dice_num = 9;
 275         dice_side = 8;
 276         break;
 277     case MonsterAbilityType::BO_COLD:
 278         mult = powerful ? 2 : 1;
 279         dam = rlev / 3 * (mult / div);
 280         dice_num = 6;
 281         dice_side = 8;
 282         break;
 283     case MonsterAbilityType::BA_LITE:
 284         dam = (rlev * 4) + 50;
 285         dice_num = 10;
 286         dice_side = 10;
 287         break;
 288     case MonsterAbilityType::BO_NETH:
 289         dam = 30 + (rlev * 4) / (powerful ? 2 : 3);
 290         dice_num = 5;
 291         dice_side = 5;
 292         break;
 293     case MonsterAbilityType::BO_WATE:
 294         dam = (rlev * 3 / (powerful ? 2 : 3));
 295         dice_num = 10;
 296         dice_side = 10;
 297         break;
 298     case MonsterAbilityType::BO_MANA:
 299         dam = 50;
 300         dice_num = 1;
 301         dice_side = rlev * 7 / 2;
 302         break;
 303     case MonsterAbilityType::BO_PLAS:
 304         dam = 10 + (rlev * 3 / (powerful ? 2 : 3));
 305         dice_num = 8;
 306         dice_side = 7;
 307         break;
 308     case MonsterAbilityType::BO_ICEE:
 309         dam = (rlev * 3 / (powerful ? 2 : 3));
 310         dice_num = 6;
 311         dice_side = 6;
 312         break;
 313     case MonsterAbilityType::MISSILE:
 314         dam = (rlev / 3);
 315         dice_num = 2;
 316         dice_side = 6;
 317         break;
 318     case MonsterAbilityType::SCARE:
 319         return -1;
 320     case MonsterAbilityType::BLIND:
 321         return -1;
 322     case MonsterAbilityType::CONF:
 323         return -1;
 324     case MonsterAbilityType::SLOW:
 325         return -1;
 326     case MonsterAbilityType::HOLD:
 327         return -1;
 328     case MonsterAbilityType::HASTE:
 329         return -1;
 330
 331     case MonsterAbilityType::HAND_DOOM:
 332         mult = player_ptr->chp;
 333         div = 100;
 334         dam = 40 * (mult / div);
 335         dice_num = 1;
 336         dice_side = 20;
 337         break;
 338
 339     case MonsterAbilityType::HEAL:
 340         return -1;
 341     case MonsterAbilityType::INVULNER:
 342         return -1;
 343     case MonsterAbilityType::BLINK:
 344         return -1;
 345     case MonsterAbilityType::TPORT:
 346         return -1;
 347     case MonsterAbilityType::WORLD:
 348         return -1;
 349     case MonsterAbilityType::SPECIAL:
 350         return -1;
 351     case MonsterAbilityType::TELE_TO:
 352         return -1;
 353     case MonsterAbilityType::TELE_AWAY:
 354         return -1;
 355     case MonsterAbilityType::TELE_LEVEL:
 356         return -1;
 357
 358     case MonsterAbilityType::PSY_SPEAR:
 359         dam = powerful ? 150 : 100;
 360         dice_num = 1;
 361         dice_side = powerful ? (rlev * 2) : (rlev * 3 / 2);
 362         break;
 363
 364     case MonsterAbilityType::DARKNESS:
 365         return -1;
 366     case MonsterAbilityType::TRAPS:
 367         return -1;
 368     case MonsterAbilityType::FORGET:
 369         return -1;
 370     case MonsterAbilityType::RAISE_DEAD:
 371         return -1;
 372     case MonsterAbilityType::S_KIN:
 373         return -1;
 374     case MonsterAbilityType::S_CYBER:
 375         return -1;
 376     case MonsterAbilityType::S_MONSTER:
 377         return -1;
 378     case MonsterAbilityType::S_MONSTERS:
 379         return -1;
 380     case MonsterAbilityType::S_ANT:
 381         return -1;
 382     case MonsterAbilityType::S_SPIDER:
 383         return -1;
 384     case MonsterAbilityType::S_HOUND:
 385         return -1;
 386     case MonsterAbilityType::S_HYDRA:
 387         return -1;
 388     case MonsterAbilityType::S_ANGEL:
 389         return -1;
 390     case MonsterAbilityType::S_DEMON:
 391         return -1;
 392     case MonsterAbilityType::S_UNDEAD:
 393         return -1;
 394     case MonsterAbilityType::S_DRAGON:
 395         return -1;
 396     case MonsterAbilityType::S_HI_UNDEAD:
 397         return -1;
 398     case MonsterAbilityType::S_HI_DRAGON:
 399         return -1;
 400     case MonsterAbilityType::S_AMBERITES:
 401         return -1;
 402     case MonsterAbilityType::S_UNIQUE:
 403         return -1;
 404     case MonsterAbilityType::MAX:
 405         return -1;
 406     }
 407
 408     return monspell_damage_roll(dam, dice_num, dice_side, mult, div, TYPE);
 409 }
 410
 411 /*!
 412  * @brief モンスターの使う射撃のダイス情報を返す /
 413  * @param r_ptr モンスター種族への参照ポインタ
 414  * @param dd ダイス数への参照ポインタ
 415  * @param ds ダイス面への参照ポインタ
 416  */
 417 void monspell_shoot_dice(monster_race *r_ptr, int *dd, int *ds)
 418 {
 419     int p = -1; /* Position of SHOOT */
 420     int n = 0; /* Number of blows */
 421     const int max_blows = 4;
 422     for (int m = 0; m < max_blows; m++) {
 423         if (r_ptr->blow[m].method != RaceBlowMethodType::NONE)
 424             n++; /* Count blows */
 425
 426         if (r_ptr->blow[m].method == RaceBlowMethodType::SHOOT) {
 427             p = m; /* Remember position */
 428             break;
 429         }
 430     }
 431
 432     /* When full blows, use a first damage */
 433     if (n == max_blows)
 434         p = 0;
 435
 436     if (p < 0) {
 437         (*dd) = 0;
 438         (*ds) = 0;
 439     } else {
 440         (*dd) = r_ptr->blow[p].d_dice;
 441         (*ds) = r_ptr->blow[p].d_side;
 442     }
 443 }
 444
 445 /*!
 446  * @brief モンスターの使う呪文の威力を返す /
 447  * @param player_ptr プレイヤーへの参照ポインタ
 448  * @param ms_type 呪文番号
 449  * @param m_idx 呪文を唱えるモンスターID
 450  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
 451  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
 452  */
 453 HIT_POINT monspell_damage(PlayerType *player_ptr, MonsterAbilityType ms_type, MONSTER_IDX m_idx, int TYPE)
 454 {
 455     floor_type *floor_ptr = player_ptr->current_floor_ptr;
 456     monster_type *m_ptr = &floor_ptr->m_list[m_idx];
 457     monster_race *r_ptr = &r_info[m_ptr->r_idx];
 458     DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
 459     HIT_POINT hp = (TYPE == DAM_ROLL) ? m_ptr->hp : m_ptr->max_maxhp;
 460     int shoot_dd, shoot_ds;
 461
 462     monspell_shoot_dice(r_ptr, &shoot_dd, &shoot_ds);
 463     return monspell_damage_base(player_ptr, ms_type, hp, rlev, monster_is_powerful(floor_ptr, m_idx), shoot_dd, shoot_ds, 0, TYPE);
 464 }
 465
 466 /*!
 467  * @brief モンスターの使う所属としての呪文の威力を返す /
 468  * @param player_ptr プレイヤーへの参照ポインタ
 469  * @param ms_type 呪文番号
 470  * @param r_idx 呪文を唱えるモンスターの種族ID
 471  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
 472  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
 473  */
 474 HIT_POINT monspell_race_damage(PlayerType *player_ptr, MonsterAbilityType ms_type, MONRACE_IDX r_idx, int TYPE)
 475 {
 476     monster_race *r_ptr = &r_info[r_idx];
 477     DEPTH rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
 478     bool powerful = any_bits(r_ptr->flags2, RF2_POWERFUL);
 479     HIT_POINT hp = r_ptr->hdice * (ironman_nightmare ? 2 : 1) * r_ptr->hside;
 480     int shoot_dd, shoot_ds;
 481
 482     monspell_shoot_dice(r_ptr, &shoot_dd, &shoot_ds);
 483     return monspell_damage_base(player_ptr, ms_type, std::min(MONSTER_MAXHP, hp), rlev, powerful, shoot_dd, shoot_ds, 0, TYPE);
 484 }
 485
 486 /*!
 487  * @brief 青魔導師の使う呪文の威力を返す /
 488  * @param player_ptr プレイヤーへの参照ポインタ
 489  * @param SPELL_NUM 呪文番号
 490  * @param plev 使用するレベル。2倍して扱う。
 491  * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
 492  * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
 493  */
 494 HIT_POINT monspell_bluemage_damage(PlayerType *player_ptr, MonsterAbilityType ms_type, PLAYER_LEVEL plev, int TYPE)
 495 {
 496     int hp = player_ptr->chp;
 497     int shoot_dd = 1, shoot_ds = 1, shoot_base = 0;
 498     object_type *o_ptr = nullptr;
 499
 500     if (has_melee_weapon(player_ptr, INVEN_MAIN_HAND))
 501         o_ptr = &player_ptr->inventory_list[INVEN_MAIN_HAND];
 502     else if (has_melee_weapon(player_ptr, INVEN_SUB_HAND))
 503         o_ptr = &player_ptr->inventory_list[INVEN_SUB_HAND];
 504
 505     if (o_ptr) {
 506         shoot_dd = o_ptr->dd;
 507         shoot_ds = o_ptr->ds;
 508         shoot_base = o_ptr->to_d;
 509     }
 510
 511     return monspell_damage_base(player_ptr, ms_type, hp, plev * 2, false, shoot_dd, shoot_ds, shoot_base, TYPE);
 512 }