Biting
![]() | |
Biting | |
---|---|
Release date | 25 January 2016 (Update) |
Gizmo type | Weapon, Armour |
Maximum rank | |
Standard | 3 |
Ancient | 4 |
In-game description | |
+2% chance per rank to critically hit opponents. | |
Infobox • Talk page |
Biting is an Invention perk that has a 2% (2.2% on a level 20 item) chance per rank to force each ability and autoattack to become a critical hit. It can be created in weapon and armour gizmos. Biting does not affect damage-over time abilities because they do not have the same critical hit mechanics as other hits.
If going for biting 2 with a standard gizmo shell while trying to avoid co-perking with cautious, it may be useful to lower one's invention level by standing in the snowy entrance area to the God Wars Dungeon, as the highest likelihood of getting this perk happens around level 30 invention, and at higher levels biting 2 without cautious becomes increasingly unlikely.
Biting does not stack with the set effect of Warpriest of Tuska armour. Additionally, the set effect takes priority over the perk, regardless which effect is greater.
When Biting causes a critical hit, the message "You deal a critical strike against your opponent!" appears in the chatbox.
The Biting perk requires Noxious components that are primarily obtained by disassembling Noxious weaponry. Alternate and more affordable methods of obtaining the components can be found on the Noxious components article.
Rank | Activation chance | Avg hit increase[r 2] |
---|---|---|
1 | +2% (2.2%) | 1.267% (1.393%) |
2 | +4% (4.4%) | 2.533% (2.786%) |
3 | +6% (6.6%) | 3.8% (4.18%) |
4 | +8% (8.8%) | 5.07% (5.572%) |
- ^ All numbers in parentheses refer to gear with item level 20.
- ^ Average hit increase is calculated based on the expected value() of receiving a critical hit from biting, Where: , is the average critical hit which is of the maximum damage, is the average hit which is 60% of the maximum damage, and is the activation chance based on the rank.
Analysis[edit | edit source]
Calculator[edit source]
Head over to the calculator page for more documentation.
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' min hits are 20% of their max hit, but some abilities also mention min hits. The min and max hit numbers can be changed, but leaving them between 20% and 100% gives correct damage increase numbers for most abilities.
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 |
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)
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(forcedCritAverageHit, minHit + 0.975 * (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) 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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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(forcedCritAverageHit, minHit + 0.975 * (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.") }
|
Cost[edit | edit source]
The cost of a Biting perk using Direct components obtained by disassembling Huge blunt adamant salvage is as follows:
Perk | Chance to obtain | Direct components | Total cost |
---|---|---|---|
Biting 1 | 51% chance at 99 Invention or higher | ![]() |
1,391,280 |
Biting 2 | 96% chance at 99 Invention or higher | ![]() |
2,434,740 |
Biting 3 | 4.8% chance at 68 Invention | ![]() |
62,607,600 |
The cost of a Biting perk using Noxious components obtained from disassembling a level 9 Noxious longbow is as follows:
Perk | Chance to obtain | Noxious components | Total cost |
---|---|---|---|
Biting 3 | 100% chance | ![]() |
39,700,185.75 |
Biting 4 | 100% chance | ![]() |
55,580,260.05 |
The cost of a Biting perk using Noxious components obtained from disassembling a level 9 Noxious staff is as follows:
Perk | Chance to obtain | Noxious components | Total cost |
---|---|---|---|
Biting 3 | 100% chance | ![]() |
43,311,220.75 |
Biting 4 | 100% chance | ![]() |
60,635,709.05 |
Sources[edit | edit source]
Material | Rarity | Perk ranks with X materials | ||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Standard gizmo | Ancient gizmo | |||||||||||||||
1 | 2 | 3 | 4 | 5 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | |||
Direct components | Uncommon | 0 | 1 | 1–2 | 1–2 | 1–3 | 0 | 1 | 1 | 1–2 | 1–2 | 1–2 | 1–3 | 1–4 | 1–4 | |
Noxious components | Rare | 0 | 1 | 2 | 2 | 3 | 0 | 1 | 1–2 | 2 | 2 | 2–3 | 3–4 | 4 | 4 | |
Blade parts | Common | 0 | 0 | 1 | 1 | 1–2 | 0 | 0 | 0 | 1 | 1 | 1 | 1–2 | 1–2 | 1–2 |
Suggested gizmos[edit | edit source]
Gizmo layout | Possible perks | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
|
| |||||||||
| 44.63% chance for Biting 4 and Undead Slayer at level 120, 49.43% with ![]()
| |||||||||
| 51.00% chance for Biting 4 and Dragon Slayer at level 120, 56.75% with ![]()
| |||||||||
| 51.00% chance for Biting 4 and Demon Slayer at level 120, 56.75% with ![]()
| |||||||||
|
| |||||||||
|
| |||||||||
|
| |||||||||
| 4.86% success chance at 68-69 invention
Open in calculator: ![]() | |||||||||
| Chance for Biting 3 increases with ![]() Biting 2 chance is unaffected by ![]()
Open in calculator: ![]() | |||||||||
| 78.09% or 1/1.28 at level 120.
Open in calculator: ![]() | |||||||||
|
Open in calculator: ![]() | |||||||||
| 57.91% or 1/1.72 at level 120. Open in calculator: ![]() | |||||||||
|
Open in calculator: ![]() | |||||||||
| 64.33% or 1/1.55 at level 120.
Open in calculator: ![]() | |||||||||
| 83.86% success chance at level 120, unaffected by ![]() Open in calculator: ![]() | |||||||||
| 49.61% or 1/2.01 at level 120. Open in calculator: ![]() | |||||||||
| 49.61% or 1/2.01 at level 120. Open in calculator: ![]() | |||||||||
|
Open in calculator: ![]() | |||||||||
|
Open in calculator: ![]() | |||||||||
|
Open in calculator: ![]() | |||||||||
|
Open in calculator: ![]() | |||||||||
|
| |||||||||
|
| |||||||||
|
Open in calculator: ![]() | |||||||||
|
Open in calculator: ![]() |
Update history[edit | edit source]
- hotfix 18 September 2017 (Update):
- The activation rate of the Biting perk was corrected, and the perk reactivated.
- hotfix 18 September 2017) (Update):
- The Biting perk was deactivated, as it was triggering too often.
- patch 6 March 2017 (Update):
- Sources of crit chance now function whilst you have the equilibrium perk or aura active. This means that both the Tuska warpriest set effect and Biting perk now stack with the Equilibrium aura and perk.
Abilities | |
Damage/Accuracy modifying | |
Damage reduction | |
Adrenaline | |
Prayer | |
Additional items | |
Experience | |
Skilling | |
Miscellaneous | |
Ancient |