Calculator:Combat/Biting Precise and Equilibrium
Calculator
This calculator is for determining the percent increase from the Biting, Precise, and Equilibrium perks; in addition, Erethdor's grimoire is included due to its similarity with the Biting perk. Only ability damage range percents are taken into consideration.
Most abilities' minimum hits are 20% of their maximum hit, but some abilities also mention minimum hits. The minimum and maximum hit numbers can be changed, but leaving them between 20% and 100% gives correct damage increase numbers for most abilities.
Many sources of damage (such as bleeds, poison, Aftershock, Summoning familiars, and Crackling) are unaffected by Biting, Precise, Equilibrium, and Erethdor's grimoire. For that reason, the damage increases shown in this calculator will likely be higher than the overall damage increase seen during combat.
Precise rank | name=precRank1|type=int|range=0,6|sublist=init |
Equilibrium rank | name=eqRank1|type=int|range=0,4|sublist=init |
Biting rank | name=bitRank1|type=int|range=0,4|sublist=init |
Is Biting on level 20 gear? | name=isLevel20_1|type=select|range=No,Yes|sublist=init |
Is Erethdor's grimoire active? | name=grimoire1|type=select|range=No,Yes|sublist=init |
Is this PvP combat? | name=isPvp1|type=select|range=No,Yes|sublist=init |
Min hit of ability | name=abilityMinHitIn1|type=number|range=0,1000|value=20|sublist=init |
Max hit of ability | name=abilityMaxHitIn1|type=number|range=0,1000|value=100|sublist=init |
Average hit without perks/grimoire | name=normalAverageHitOut1|type=output |
Min hit with perks | name=abilityMinHitOut1|type=output |
Max hit with perks | name=abilityMaxHitOut1|type=output |
Average hit with perks/grimoire | name=perkAverageHitOut1|type=output |
% damage increase from perks/grimoire | name=percentIncreaseOut1|type=output |
let(precRank, precRank1) let(eqRank, eqRank1) let(bitRank, bitRank1) let(minHit, abilityMinHitIn1) let(maxHit, abilityMaxHitIn1) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_1) let(grim, grimoire1) let(pvp, isPvp1)
if(minHit < maxHit){
let(minHit, minHit + 0.015 * precRank * maxHit)
let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn1 - minHit))
let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)
let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000)
let(normalAverageHitOut1, normalAverageHit) let(abilityMinHitOut1, minHit) let(abilityMaxHitOut1, maxHit) let(perkAverageHitOut1, perkAverageHit) let(percentIncreaseOut1, damageIncrease) let(wrongInput1, "")
}{
let(normalAverageHitOut1, 60) let(abilityMinHitOut1, 20) let(abilityMaxHitOut1, 100) let(perkAverageHitOut1, 60) let(percentIncreaseOut1, 0) let(wrongInput1, "Please give a correct minimum and maximum ability damage.")
}
Full table of Biting Precise and Equilibrium Combinations | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
List of damage increases for various precise and equilibrium combinations, given a certain rank of biting (and whether or not Erethdor's grimoire is active).
type=button|sublist=init|value=Calculate
name=wrongInput2|type=output
init|
let(precRank, 6) let(eqRank, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2) if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(normalAverageHitOut2, normalAverageHit) let(minHitP6E4, minHit) let(maxHitP6E4, maxHit) let(averageHitP6E4, perkAverageHit) let(damageIncreaseP6E4, damageIncrease) let(wrongInput2, "") }{ let(normalAverageHitOut2, 60) let(minHitP6E4, 20) let(maxHitP6E4, 100) let(averageHitP6E4, 60) let(damageIncreaseP6E4, 0) let(wrongInput2, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP6E3, minHit) let(maxHitP6E3, maxHit) let(averageHitP6E3, perkAverageHit) let(damageIncreaseP6E3, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP6E3, 20) let(maxHitP6E3, 100) let(averageHitP6E3, 60) let(damageIncreaseP6E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP6E2, minHit) let(maxHitP6E2, maxHit) let(averageHitP6E2, perkAverageHit) let(damageIncreaseP6E2, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP6E2, 20) let(maxHitP6E2, 100) let(averageHitP6E2, 60) let(damageIncreaseP6E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP6E1, minHit) let(maxHitP6E1, maxHit) let(averageHitP6E1, perkAverageHit) let(damageIncreaseP6E1, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP6E1, 20) let(maxHitP6E1, 100) let(averageHitP6E1, 60) let(damageIncreaseP6E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP6E0, minHit) let(maxHitP6E0, maxHit) let(averageHitP6E0, perkAverageHit) let(damageIncreaseP6E0, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP6E0, 20) let(maxHitP6E0, 100) let(averageHitP6E0, 60) let(damageIncreaseP6E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP5E4, minHit) let(maxHitP5E4, maxHit) let(averageHitP5E4, perkAverageHit) let(damageIncreaseP5E4, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP5E4, 20) let(maxHitP5E4, 100) let(averageHitP5E4, 60) let(damageIncreaseP5E4, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP5E3, minHit) let(maxHitP5E3, maxHit) let(averageHitP5E3, perkAverageHit) let(damageIncreaseP5E3, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP5E3, 20) let(maxHitP5E3, 100) let(averageHitP5E3, 60) let(damageIncreaseP5E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP5E2, minHit) let(maxHitP5E2, maxHit) let(averageHitP5E2, perkAverageHit) let(damageIncreaseP5E2, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP5E2, 20) let(maxHitP5E2, 100) let(averageHitP5E2, 60) let(damageIncreaseP5E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP5E1, minHit) let(maxHitP5E1, maxHit) let(averageHitP5E1, perkAverageHit) let(damageIncreaseP5E1, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP5E1, 20) let(maxHitP5E1, 100) let(averageHitP5E1, 60) let(damageIncreaseP5E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP5E0, minHit) let(maxHitP5E0, maxHit) let(averageHitP5E0, perkAverageHit) let(damageIncreaseP5E0, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP5E0, 20) let(maxHitP5E0, 100) let(averageHitP5E0, 60) let(damageIncreaseP5E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP4E4, minHit) let(maxHitP4E4, maxHit) let(averageHitP4E4, perkAverageHit) let(damageIncreaseP4E4, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP4E4, 20) let(maxHitP4E4, 100) let(averageHitP4E4, 60) let(damageIncreaseP4E4, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP4E3, minHit) let(maxHitP4E3, maxHit) let(averageHitP4E3, perkAverageHit) let(damageIncreaseP4E3, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP4E3, 20) let(maxHitP4E3, 100) let(averageHitP4E3, 60) let(damageIncreaseP4E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP4E2, minHit) let(maxHitP4E2, maxHit) let(averageHitP4E2, perkAverageHit) let(damageIncreaseP4E2, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP4E2, 20) let(maxHitP4E2, 100) let(averageHitP4E2, 60) let(damageIncreaseP4E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP4E1, minHit) let(maxHitP4E1, maxHit) let(averageHitP4E1, perkAverageHit) let(damageIncreaseP4E1, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP4E1, 20) let(maxHitP4E1, 100) let(averageHitP4E1, 60) let(damageIncreaseP4E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP4E0, minHit) let(maxHitP4E0, maxHit) let(averageHitP4E0, perkAverageHit) let(damageIncreaseP4E0, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP4E0, 20) let(maxHitP4E0, 100) let(averageHitP4E0, 60) let(damageIncreaseP4E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP3E4, minHit) let(maxHitP3E4, maxHit) let(averageHitP3E4, perkAverageHit) let(damageIncreaseP3E4, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP3E4, 20) let(maxHitP3E4, 100) let(averageHitP3E4, 60) let(damageIncreaseP3E4, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP3E3, minHit) let(maxHitP3E3, maxHit) let(averageHitP3E3, perkAverageHit) let(damageIncreaseP3E3, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP3E3, 20) let(maxHitP3E3, 100) let(averageHitP3E3, 60) let(damageIncreaseP3E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP3E2, minHit) let(maxHitP3E2, maxHit) let(averageHitP3E2, perkAverageHit) let(damageIncreaseP3E2, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP3E2, 20) let(maxHitP3E2, 100) let(averageHitP3E2, 60) let(damageIncreaseP3E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP3E1, minHit) let(maxHitP3E1, maxHit) let(averageHitP3E1, perkAverageHit) let(damageIncreaseP3E1, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP3E1, 20) let(maxHitP3E1, 100) let(averageHitP3E1, 60) let(damageIncreaseP3E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP3E0, minHit) let(maxHitP3E0, maxHit) let(averageHitP3E0, perkAverageHit) let(damageIncreaseP3E0, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP3E0, 20) let(maxHitP3E0, 100) let(averageHitP3E0, 60) let(damageIncreaseP3E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP2E4, minHit) let(maxHitP2E4, maxHit) let(averageHitP2E4, perkAverageHit) let(damageIncreaseP2E4, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP2E4, 20) let(maxHitP2E4, 100) let(averageHitP2E4, 60) let(damageIncreaseP2E4, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP2E3, minHit) let(maxHitP2E3, maxHit) let(averageHitP2E3, perkAverageHit) let(damageIncreaseP2E3, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP2E3, 20) let(maxHitP2E3, 100) let(averageHitP2E3, 60) let(damageIncreaseP2E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP2E2, minHit) let(maxHitP2E2, maxHit) let(averageHitP2E2, perkAverageHit) let(damageIncreaseP2E2, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP2E2, 20) let(maxHitP2E2, 100) let(averageHitP2E2, 60) let(damageIncreaseP2E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP2E1, minHit) let(maxHitP2E1, maxHit) let(averageHitP2E1, perkAverageHit) let(damageIncreaseP2E1, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP2E1, 20) let(maxHitP2E1, 100) let(averageHitP2E1, 60) let(damageIncreaseP2E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP2E0, minHit) let(maxHitP2E0, maxHit) let(averageHitP2E0, perkAverageHit) let(damageIncreaseP2E0, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP2E0, 20) let(maxHitP2E0, 100) let(averageHitP2E0, 60) let(damageIncreaseP2E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP1E4, minHit) let(maxHitP1E4, maxHit) let(averageHitP1E4, perkAverageHit) let(damageIncreaseP1E4, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP1E4, 20) let(maxHitP1E4, 100) let(averageHitP1E4, 60) let(damageIncreaseP1E4, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP1E3, minHit) let(maxHitP1E3, maxHit) let(averageHitP1E3, perkAverageHit) let(damageIncreaseP1E3, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP1E3, 20) let(maxHitP1E3, 100) let(averageHitP1E3, 60) let(damageIncreaseP1E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP1E2, minHit) let(maxHitP1E2, maxHit) let(averageHitP1E2, perkAverageHit) let(damageIncreaseP1E2, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP1E2, 20) let(maxHitP1E2, 100) let(averageHitP1E2, 60) let(damageIncreaseP1E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP1E1, minHit) let(maxHitP1E1, maxHit) let(averageHitP1E1, perkAverageHit) let(damageIncreaseP1E1, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP1E1, 20) let(maxHitP1E1, 100) let(averageHitP1E1, 60) let(damageIncreaseP1E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP1E0, minHit) let(maxHitP1E0, maxHit) let(averageHitP1E0, perkAverageHit) let(damageIncreaseP1E0, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP1E0, 20) let(maxHitP1E0, 100) let(averageHitP1E0, 60) let(damageIncreaseP1E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP0E4, minHit) let(maxHitP0E4, maxHit) let(averageHitP0E4, perkAverageHit) let(damageIncreaseP0E4, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP0E4, 20) let(maxHitP0E4, 100) let(averageHitP0E4, 60) let(damageIncreaseP0E4, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP0E3, minHit) let(maxHitP0E3, maxHit) let(averageHitP0E3, perkAverageHit) let(damageIncreaseP0E3, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP0E3, 20) let(maxHitP0E3, 100) let(averageHitP0E3, 60) let(damageIncreaseP0E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP0E2, minHit) let(maxHitP0E2, maxHit) let(averageHitP0E2, perkAverageHit) let(damageIncreaseP0E2, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP0E2, 20) let(maxHitP0E2, 100) let(averageHitP0E2, 60) let(damageIncreaseP0E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP0E1, minHit) let(maxHitP0E1, maxHit) let(averageHitP0E1, perkAverageHit) let(damageIncreaseP0E1, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP0E1, 20) let(maxHitP0E1, 100) let(averageHitP0E1, 60) let(damageIncreaseP0E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(pvpLowerCrits, .145 * pvp) let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit) let(damageIncrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIncrease, round(damageIncrease * 1000)) let(damageIncrease, damageIncrease / 1000) let(n, normalAverageHit) let(minHitP0E0, minHit) let(maxHitP0E0, maxHit) let(averageHitP0E0, perkAverageHit) let(damageIncreaseP0E0, damageIncrease) let(n, "") }{ let(n, 60) let(minHitP0E0, 20) let(maxHitP0E0, 100) let(averageHitP0E0, 60) let(damageIncreaseP0E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
|
Precise Rank
The rank of the precise perk on your gizmo. Accepted values are all integers from 0 to 6.
Equilibrium Rank
The rank of the equilibrium perk on your gizmo. Accepted values are all integers from 0 to 4.
Biting Rank
The rank of the biting perk on your gizmo. Accepted values are all integers from 0 to 4.
Is biting on level 20 gear?
Level 20 gear provides an extra 10% chance (multiplicative) for biting to trigger, so this will affect the final result. This only works if the biting perk itself is on a piece of gear that is level 20.
Is Erethdor's grimoire active?
Erethdor's grimoire acts very similar to Biting in that it affects critical hit chance.
Is this PvP combat?
Forced critical hits in PvP deal less damage than in PvM. Forced critical hits in PvM deal between 95-100% of the range of the ability. Forced critical hits in PvP deal between 66-100 of the range of the ability.
Min hit and Max hit of ability
These are the damage values displayed on the ability tooltip. If the tooltip only gives a maximum value then the minimum hit is 20% of the maximum hit. Note that exact values of the ability damage do not matter, it is the ratio between the min and maximum damage that determines the damage increase. Example: Sonic Waves tooltip states that it hit 157% of your ability damage. So max hit = 157% and min hit is 20% * 157% = 31.4%. But since 31.4%-157% is a 1:5 ratio it will give the same result if we just use 20%-100% (also a 1:5 ratio). All abilities that only give one damage value in their tooltip are 1:5 abilities and can be calculated with 20%-100% as input.
Average Hit without perks and grimoire
The average percentage of your ability damage that you will hit without perks and without an active grimoire.
Min Hit and Max hit with perks
These are the new min and max hits of the ability after the effect of the perks are applied.
% damage increase from perks and grimoire
The average damage increase that the perks and grimoire provide given in percent.