src/mspell/mspell-damage-calculator.c

   1 #include "system/angband.h"
   2 #include "floor/floor.h"
   3 #include "game-option/birth-options.h"
   4 #include "monster-race/monster-race.h"
   5 #include "monster-race/race-flags2.h"
   6 #include "mspell/mspell-type.h"
   7 #include "mspell/mspell-damage-calculator.h"
   8 #include "mspell/monster-spell.h"
   9 #include "monster/monster-status.h"
  10
  11 /*!
  12 * @brief モンスターの使う呪文の威力を決定する /
  13 * @param dam 定数値
  14 * @param dice_num ダイス数
  15 * @param dice_side ダイス面
  16 * @param mult ダイス倍率
  17 * @param div ダイス倍率
  18 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
  19 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  20 */
  21 static HIT_POINT monspell_damage_roll(HIT_POINT dam, int dice_num, int dice_side, int mult, int div, int TYPE)
  22 {
  23     switch (TYPE) {
  24     case DAM_MAX:
  25         dam += maxroll(dice_num, dice_side) * mult / div;
  26         break;
  27     case DAM_MIN:
  28         dam += dice_num * 1 * mult / div;
  29         break;
  30     case DAM_ROLL:
  31         dam += damroll(dice_num, dice_side) * mult / div;
  32         break;
  33     case DICE_NUM:
  34         return dice_num;
  35     case DICE_SIDE:
  36         return dice_side;
  37     case DICE_MULT:
  38         return mult;
  39     case DICE_DIV:
  40         return div;
  41     case BASE_DAM:
  42         return dam;
  43     }
  44
  45     if (dam < 1)
  46         dam = 1;
  47     return dam;
  48 }
  49
  50 /*!
  51 * @brief モンスターの使う呪文の威力を返す /
  52 * @param target_ptr プレーヤーへの参照ポインタ (破滅の手用)
  53 * @param SPELL_NUM 呪文番号
  54 * @param hp 呪文を唱えるモンスターの体力
  55 * @param rlev 呪文を唱えるモンスターのレベル
  56 * @param powerful 呪文を唱えるモンスターのpowerfulフラグ
  57 * @param shoot_dd 射撃のダイス数
  58 * @param shoot_ds 射撃のダイス面
  59 * @param shoot_base 射撃の固定威力値
  60 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
  61 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
  62 */
  63 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)
  64 {
  65     HIT_POINT dam = 0, dice_num = 0, dice_side = 0, mult = 1, div = 1;
  66
  67     switch (ms_type) {
  68     case MS_SHRIEK:
  69         return -1;
  70     case MS_XXX1:
  71         return -1;
  72     case MS_DISPEL:
  73         return -1;
  74     case MS_ROCKET:
  75         dam = (hp / 4) > 800 ? 800 : (hp / 4);
  76         break;
  77     case MS_SHOOT:
  78         dice_num = shoot_dd;
  79         dice_side = shoot_ds;
  80         dam = shoot_base;
  81         break;
  82     case MS_XXX2:
  83         return -1;
  84     case MS_XXX3:
  85         return -1;
  86     case MS_XXX4:
  87         return -1;
  88
  89     case MS_BR_ACID:
  90     case MS_BR_ELEC:
  91     case MS_BR_FIRE:
  92     case MS_BR_COLD:
  93         dam = ((hp / 3) > 1600 ? 1600 : (hp / 3));
  94         break;
  95     case MS_BR_POIS:
  96         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
  97         break;
  98     case MS_BR_NETHER:
  99         dam = ((hp / 6) > 550 ? 550 : (hp / 6));
 100         break;
 101     case MS_BR_LITE:
 102     case MS_BR_DARK:
 103         dam = ((hp / 6) > 400 ? 400 : (hp / 6));
 104         break;
 105     case MS_BR_CONF:
 106     case MS_BR_SOUND:
 107         dam = ((hp / 6) > 450 ? 450 : (hp / 6));
 108         break;
 109     case MS_BR_CHAOS:
 110         dam = ((hp / 6) > 600 ? 600 : (hp / 6));
 111         break;
 112     case MS_BR_DISEN:
 113         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
 114         break;
 115     case MS_BR_NEXUS:
 116         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
 117         break;
 118     case MS_BR_TIME:
 119         dam = ((hp / 3) > 150 ? 150 : (hp / 3));
 120         break;
 121     case MS_BR_INERTIA:
 122     case MS_BR_GRAVITY:
 123         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
 124         break;
 125     case MS_BR_SHARDS:
 126         dam = ((hp / 6) > 500 ? 500 : (hp / 6));
 127         break;
 128     case MS_BR_PLASMA:
 129         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
 130         break;
 131     case MS_BR_FORCE:
 132         dam = ((hp / 6) > 200 ? 200 : (hp / 6));
 133         break;
 134     case MS_BR_MANA:
 135         dam = ((hp / 3) > 250 ? 250 : (hp / 3));
 136         break;
 137     case MS_BALL_NUKE:
 138         mult = powerful ? 2 : 1;
 139         dam = rlev * (mult / div);
 140         dice_num = 10;
 141         dice_side = 6;
 142         break;
 143     case MS_BR_NUKE:
 144         dam = ((hp / 3) > 800 ? 800 : (hp / 3));
 145         break;
 146     case MS_BALL_CHAOS:
 147         dam = (powerful ? (rlev * 3) : (rlev * 2));
 148         dice_num = 10;
 149         dice_side = 10;
 150         break;
 151     case MS_BR_DISI:
 152         dam = ((hp / 6) > 150 ? 150 : (hp / 6));
 153         break;
 154     case MS_BALL_ACID:
 155         if (powerful) {
 156             dam = (rlev * 4) + 50;
 157             dice_num = 10;
 158             dice_side = 10;
 159         } else {
 160             dam = 15;
 161             dice_num = 1;
 162             dice_side = rlev * 3;
 163         }
 164
 165         break;
 166     case MS_BALL_ELEC:
 167         if (powerful) {
 168             dam = (rlev * 4) + 50;
 169             dice_num = 10;
 170             dice_side = 10;
 171         } else {
 172             dam = 8;
 173             dice_num = 1;
 174             dice_side = rlev * 3 / 2;
 175         }
 176
 177         break;
 178     case MS_BALL_FIRE:
 179         if (powerful) {
 180             dam = (rlev * 4) + 50;
 181             dice_num = 10;
 182             dice_side = 10;
 183         } else {
 184             dam = 10;
 185             dice_num = 1;
 186             dice_side = rlev * 7 / 2;
 187         }
 188
 189         break;
 190     case MS_BALL_COLD:
 191         if (powerful) {
 192             dam = (rlev * 4) + 50;
 193             dice_num = 10;
 194             dice_side = 10;
 195         } else {
 196             dam = 10;
 197             dice_num = 1;
 198             dice_side = rlev * 3 / 2;
 199         }
 200
 201         break;
 202     case MS_BALL_POIS:
 203         mult = powerful ? 2 : 1;
 204         dice_num = 12;
 205         dice_side = 2;
 206         break;
 207     case MS_BALL_NETHER:
 208         dam = 50 + rlev * (powerful ? 2 : 1);
 209         dice_num = 10;
 210         dice_side = 10;
 211         break;
 212     case MS_BALL_WATER:
 213         dam = 50;
 214         dice_num = 1;
 215         dice_side = powerful ? (rlev * 3) : (rlev * 2);
 216         break;
 217     case MS_BALL_MANA:
 218     case MS_BALL_DARK:
 219         dam = (rlev * 4) + 50;
 220         dice_num = 10;
 221         dice_side = 10;
 222         break;
 223     case MS_DRAIN_MANA:
 224         dam = rlev;
 225         div = 1;
 226         dice_num = 1;
 227         dice_side = rlev;
 228         break;
 229     case MS_MIND_BLAST:
 230         dice_num = 7;
 231         dice_side = 7;
 232         break;
 233     case MS_BRAIN_SMASH:
 234         dice_num = 12;
 235         dice_side = 12;
 236         break;
 237     case MS_CAUSE_1:
 238         dice_num = 3;
 239         dice_side = 8;
 240         break;
 241     case MS_CAUSE_2:
 242         dice_num = 8;
 243         dice_side = 8;
 244         break;
 245     case MS_CAUSE_3:
 246         dice_num = 10;
 247         dice_side = 15;
 248         break;
 249     case MS_CAUSE_4:
 250         dice_num = 15;
 251         dice_side = 15;
 252         break;
 253     case MS_BOLT_ACID:
 254         mult = powerful ? 2 : 1;
 255         dam = rlev / 3 * (mult / div);
 256         dice_num = 7;
 257         dice_side = 8;
 258         break;
 259     case MS_BOLT_ELEC:
 260         mult = powerful ? 2 : 1;
 261         dam = rlev / 3 * (mult / div);
 262         dice_num = 4;
 263         dice_side = 8;
 264         break;
 265     case MS_BOLT_FIRE:
 266         mult = powerful ? 2 : 1;
 267         dam = rlev / 3 * (mult / div);
 268         dice_num = 9;
 269         dice_side = 8;
 270         break;
 271     case MS_BOLT_COLD:
 272         mult = powerful ? 2 : 1;
 273         dam = rlev / 3 * (mult / div);
 274         dice_num = 6;
 275         dice_side = 8;
 276         break;
 277     case MS_STARBURST:
 278         dam = (rlev * 4) + 50;
 279         dice_num = 10;
 280         dice_side = 10;
 281         break;
 282     case MS_BOLT_NETHER:
 283         dam = 30 + (rlev * 4) / (powerful ? 2 : 3);
 284         dice_num = 5;
 285         dice_side = 5;
 286         break;
 287     case MS_BOLT_WATER:
 288         dam = (rlev * 3 / (powerful ? 2 : 3));
 289         dice_num = 10;
 290         dice_side = 10;
 291         break;
 292     case MS_BOLT_MANA:
 293         dam = 50;
 294         dice_num = 1;
 295         dice_side = rlev * 7 / 2;
 296         break;
 297     case MS_BOLT_PLASMA:
 298         dam = 10 + (rlev * 3 / (powerful ? 2 : 3));
 299         dice_num = 8;
 300         dice_side = 7;
 301         break;
 302     case MS_BOLT_ICE:
 303         dam = (rlev * 3 / (powerful ? 2 : 3));
 304         dice_num = 6;
 305         dice_side = 6;
 306         break;
 307     case MS_MAGIC_MISSILE:
 308         dam = (rlev / 3);
 309         dice_num = 2;
 310         dice_side = 6;
 311         break;
 312     case MS_SCARE:
 313         return -1;
 314     case MS_BLIND:
 315         return -1;
 316     case MS_CONF:
 317         return -1;
 318     case MS_SLOW:
 319         return -1;
 320     case MS_SLEEP:
 321         return -1;
 322     case MS_SPEED:
 323         return -1;
 324
 325     case MS_HAND_DOOM:
 326         mult = target_ptr->chp;
 327         div = 100;
 328         dam = 40 * (mult / div);
 329         dice_num = 1;
 330         dice_side = 20;
 331         break;
 332
 333     case MS_HEAL:
 334         return -1;
 335     case MS_INVULNER:
 336         return -1;
 337     case MS_BLINK:
 338         return -1;
 339     case MS_TELEPORT:
 340         return -1;
 341     case MS_WORLD:
 342         return -1;
 343     case MS_SPECIAL:
 344         return -1;
 345     case MS_TELE_TO:
 346         return -1;
 347     case MS_TELE_AWAY:
 348         return -1;
 349     case MS_TELE_LEVEL:
 350         return -1;
 351
 352     case MS_PSY_SPEAR:
 353         dam = powerful ? 150 : 100;
 354         dice_num = 1;
 355         dice_side = powerful ? (rlev * 2) : (rlev * 3 / 2);
 356         break;
 357
 358     case MS_DARKNESS:
 359         return -1;
 360     case MS_MAKE_TRAP:
 361         return -1;
 362     case MS_FORGET:
 363         return -1;
 364     case MS_RAISE_DEAD:
 365         return -1;
 366     case MS_S_KIN:
 367         return -1;
 368     case MS_S_CYBER:
 369         return -1;
 370     case MS_S_MONSTER:
 371         return -1;
 372     case MS_S_MONSTERS:
 373         return -1;
 374     case MS_S_ANT:
 375         return -1;
 376     case MS_S_SPIDER:
 377         return -1;
 378     case MS_S_HOUND:
 379         return -1;
 380     case MS_S_HYDRA:
 381         return -1;
 382     case MS_S_ANGEL:
 383         return -1;
 384     case MS_S_DEMON:
 385         return -1;
 386     case MS_S_UNDEAD:
 387         return -1;
 388     case MS_S_DRAGON:
 389         return -1;
 390     case MS_S_HI_UNDEAD:
 391         return -1;
 392     case MS_S_HI_DRAGON:
 393         return -1;
 394     case MS_S_AMBERITE:
 395         return -1;
 396     case MS_S_UNIQUE:
 397         return -1;
 398     }
 399
 400     return monspell_damage_roll(dam, dice_num, dice_side, mult, div, TYPE);
 401 }
 402
 403 /*!
 404 * @brief モンスターの使う呪文の威力を返す /
 405 * @param target_ptr プレーヤーへの参照ポインタ
 406 * @param SPELL_NUM 呪文番号
 407 * @param m_idx 呪文を唱えるモンスターID
 408 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
 409 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
 410 */
 411 HIT_POINT monspell_damage(player_type* target_ptr, monster_spell_type ms_type, MONSTER_IDX m_idx, int TYPE)
 412 {
 413     floor_type* floor_ptr = target_ptr->current_floor_ptr;
 414     monster_type* m_ptr = &floor_ptr->m_list[m_idx];
 415     monster_race* r_ptr = &r_info[m_ptr->r_idx];
 416     int hp;
 417     DEPTH rlev = monster_level_idx(floor_ptr, m_idx);
 418     int shoot_dd = r_ptr->blow[0].d_dice;
 419     int shoot_ds = r_ptr->blow[0].d_side;
 420
 421     hp = (TYPE == DAM_ROLL) ? m_ptr->hp : m_ptr->max_maxhp;
 422     return monspell_damage_base(target_ptr, ms_type, hp, rlev, monster_is_powerful(floor_ptr, m_idx), shoot_dd, shoot_ds, 0, TYPE);
 423 }
 424
 425 /*!
 426 * @brief モンスターの使う呪文の威力を返す /
 427 * @param target_ptr プレーヤーへの参照ポインタ
 428 * @param SPELL_NUM 呪文番号
 429 * @param r_idx 呪文を唱えるモンスターの種族ID
 430 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
 431 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
 432 */
 433 HIT_POINT monspell_race_damage(player_type* target_ptr, monster_spell_type ms_type, MONRACE_IDX r_idx, int TYPE)
 434 {
 435     monster_race* r_ptr = &r_info[r_idx];
 436     int rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
 437     bool powerful = r_ptr->flags2 & RF2_POWERFUL ? TRUE : FALSE;
 438     u32b hp = r_ptr->hdice * (ironman_nightmare ? 2 : 1) * r_ptr->hside;
 439     int shoot_dd = r_ptr->blow[0].d_dice;
 440     int shoot_ds = r_ptr->blow[0].d_side;
 441
 442     return monspell_damage_base(target_ptr, ms_type, MIN(30000, hp), rlev, powerful, shoot_dd, shoot_ds, 0, TYPE);
 443 }
 444
 445 /*!
 446 * @brief 青魔導師の使う呪文の威力を返す /
 447 * @param target_ptr プレーヤーへの参照ポインタ
 448 * @param SPELL_NUM 呪文番号
 449 * @param plev 使用するレベル。2倍して扱う。
 450 * @param TYPE  DAM_MAXで最大値を返し、DAM_MINで最小値を返す。DAM_ROLLはダイスを振って値を決定する。
 451 * @return 攻撃呪文のダメージを返す。攻撃呪文以外は-1を返す。
 452 */
 453 HIT_POINT monspell_bluemage_damage(player_type* target_ptr, monster_spell_type ms_type, PLAYER_LEVEL plev, int TYPE)
 454 {
 455     int hp = target_ptr->chp;
 456     int shoot_dd = 1, shoot_ds = 1, shoot_base = 0;
 457     object_type* o_ptr = NULL;
 458
 459     if (has_melee_weapon(target_ptr, INVEN_RARM))
 460         o_ptr = &target_ptr->inventory_list[INVEN_RARM];
 461     else if (has_melee_weapon(target_ptr, INVEN_LARM))
 462         o_ptr = &target_ptr->inventory_list[INVEN_LARM];
 463
 464     if (o_ptr) {
 465         shoot_dd = o_ptr->dd;
 466         shoot_ds = o_ptr->ds;
 467         shoot_base = o_ptr->to_d;
 468     }
 469
 470     return monspell_damage_base(target_ptr, ms_type, hp, plev * 2, FALSE, shoot_dd, shoot_ds, shoot_base, TYPE);
 471 }