Equilibrium

For the aura, see Equilibrium aura.

Equilibrium
Release date	25 January 2016 (Update)
Gizmo type	Weapon
Maximum rank	4
Description?
Increases minimum hit by 3% per rank, and decreases maximum hit by 1% per rank. Does not stack with Equilibrium aura; aura takes precedence.
Infobox • Talk page

Equilibrium is an Invention perk that increases minimum hit, but also lowers maximum hit. It can be created in weapon gizmos.

Suppose an ability has ability damage that ranges from a minimum of 20% to a maximum of 100% ability damage. Equilibrium will reduce the maximum hit and increase the minimum hit by 1% and 3% respectively of the damage range, here 80% (as 100 - 20 = 80). As a result, Equilibrium will increase minimum hit by 2.4% per rank and decrease maximum hit by 0.8% per rank. This ability will thus hit 22.4% - 99.2% of the stated damage with rank 1, between 24.8% - 98.4% of the stated damage at rank 2, and 27.2% - 97.6% of the stated damage at rank 3.

From ingame testing, Equilibrium changes the minimum natural critical hit such that the chance of landing a natural critical hit is the same as without Equilibrium. More information can be found here.

Bleed abilities are not affected by Equilibrium.

Average damage increase

Min/max hit changes			Standard hit
Rank	Min	Max	Min	Max	Avg hit increase
None	±0%	±0%	20.0%	100.0%	0.0%
1	+3%	−1%	22.4%	99.2%	1.3%
2	+6%	−2%	24.8%	98.4%	2.7%
3	+9%	−3%	27.2%	97.6%	4.0%
4	+12%	−4%	29.6%	96.8%	5.3%

Combining Equilibrium with Precise

Equilibrium perk can be combined with Precise perk in a single gizmo. The ideal weapon perk setup includes a gizmo on off-hand or 2h weapon containing Precise 4 with Equilibrium 2 (obtained from five precise components) or Precise 5 with Equilibrium 1 (obtained from one Armadyl component and four precise components). This provides a ~1% damage increase over Precise 5. Both of these combinations are very rare and expensive to obtain. Level 120 Invention and an extreme invention potion are strongly advised before attempting to create gizmos with these perk combinations.

Analysis

Calculator

This dynamic calculator requires JavaScript. This page takes user input via JavaScript and may use changing prices from the Grand Exchange Market Watch.

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

type=button|sublist=init|value=Calculate

name=wrongInput1|type=output

init|

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). = perks you can get on one gizmo $\left({\text{there exists a combination with chance}}\geq {\frac {1}{2000}}\right)$. = perks you can not get on one gizmo $\left({\text{all possibile combinations have chance}}<{\frac {1}{2000}}\right)$. Biting Rank name=bitRank2|type=int|range=0,4|sublist=init Is Biting on level 20 gear? name=isLevel20_2|type=select|range=No,Yes|sublist=init Is Erethdor's grimoire active? name=grimoire2|type=select|range=No,Yes|sublist=init Min hit of ability name=abilityMinHitIn2|type=number|range=0,1000|value=20|sublist=init Max hit of ability name=abilityMaxHitIn2|type=number|range=0,1000|value=100|sublist=init Average hit without perks/grimoire name=normalAverageHitOut2|type=output 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.") } let(precRank, 6) let(eqRank, 3) 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(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.") } let(precRank, 6) let(eqRank, 2) 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(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.") } let(precRank, 6) let(eqRank, 1) 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(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.") } let(precRank, 6) let(eqRank, 0) 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(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.") } let(precRank, 5) 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(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.") } let(precRank, 5) let(eqRank, 3) 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(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.") } let(precRank, 5) let(eqRank, 2) 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(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.") } let(precRank, 5) let(eqRank, 1) 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(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.") } let(precRank, 5) let(eqRank, 0) 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(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.") } let(precRank, 4) 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(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.") } let(precRank, 4) let(eqRank, 3) 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(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.") } let(precRank, 4) let(eqRank, 2) 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(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.") } let(precRank, 4) let(eqRank, 1) 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(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.") } let(precRank, 4) let(eqRank, 0) 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(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.") } let(precRank, 3) 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(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.") } let(precRank, 3) let(eqRank, 3) 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(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.") } let(precRank, 3) let(eqRank, 2) 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(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.") } let(precRank, 3) let(eqRank, 1) 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(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.") } let(precRank, 3) let(eqRank, 0) 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(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.") } let(precRank, 2) 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(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.") } let(precRank, 2) let(eqRank, 3) 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(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.") } let(precRank, 2) let(eqRank, 2) 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(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.") } let(precRank, 2) let(eqRank, 1) 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(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.") } let(precRank, 2) let(eqRank, 0) 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(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.") } let(precRank, 1) 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(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.") } let(precRank, 1) let(eqRank, 3) 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(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.") } let(precRank, 1) let(eqRank, 2) 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(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.") } let(precRank, 1) let(eqRank, 1) 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(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.") } let(precRank, 1) let(eqRank, 0) 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(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.") } let(precRank, 0) 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(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.") } let(precRank, 0) let(eqRank, 3) 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(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.") } let(precRank, 0) let(eqRank, 2) 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(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.") } let(precRank, 0) let(eqRank, 1) 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(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.") } let(precRank, 0) let(eqRank, 0) 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(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.") } P E Min hit Max hit Average Hit % damage increase 6 4 name=minHitP6E4|type=output name=maxHitP6E4|type=output name=averageHitP6E4|type=output name=damageIncreaseP6E4|type=output 6 3 name=minHitP6E3|type=output name=maxHitP6E3|type=output name=averageHitP6E3|type=output name=damageIncreaseP6E3|type=output 6 2 name=minHitP6E2|type=output name=maxHitP6E2|type=output name=averageHitP6E2|type=output name=damageIncreaseP6E2|type=output 6 1 name=minHitP6E1|type=output name=maxHitP6E1|type=output name=averageHitP6E1|type=output name=damageIncreaseP6E1|type=output 6 0 name=minHitP6E0|type=output name=maxHitP6E0|type=output name=averageHitP6E0|type=output name=damageIncreaseP6E0|type=output 5 4 name=minHitP5E4|type=output name=maxHitP5E4|type=output name=averageHitP5E4|type=output name=damageIncreaseP5E4|type=output 5 3 name=minHitP5E3|type=output name=maxHitP5E3|type=output name=averageHitP5E3|type=output name=damageIncreaseP5E3|type=output 5 2 name=minHitP5E2|type=output name=maxHitP5E2|type=output name=averageHitP5E2|type=output name=damageIncreaseP5E2|type=output 5 1 name=minHitP5E1|type=output name=maxHitP5E1|type=output name=averageHitP5E1|type=output name=damageIncreaseP5E1|type=output 5 0 name=minHitP5E0|type=output name=maxHitP5E0|type=output name=averageHitP5E0|type=output name=damageIncreaseP5E0|type=output 4 4 name=minHitP4E4|type=output name=maxHitP4E4|type=output name=averageHitP4E4|type=output name=damageIncreaseP4E4|type=output 4 3 name=minHitP4E3|type=output name=maxHitP4E3|type=output name=averageHitP4E3|type=output name=damageIncreaseP4E3|type=output 4 2 name=minHitP4E2|type=output name=maxHitP4E2|type=output name=averageHitP4E2|type=output name=damageIncreaseP4E2|type=output 4 1 name=minHitP4E1|type=output name=maxHitP4E1|type=output name=averageHitP4E1|type=output name=damageIncreaseP4E1|type=output 4 0 name=minHitP4E0|type=output name=maxHitP4E0|type=output name=averageHitP4E0|type=output name=damageIncreaseP4E0|type=output 3 4 name=minHitP3E4|type=output name=maxHitP3E4|type=output name=averageHitP3E4|type=output name=damageIncreaseP3E4|type=output 3 3 name=minHitP3E3|type=output name=maxHitP3E3|type=output name=averageHitP3E3|type=output name=damageIncreaseP3E3|type=output 3 2 name=minHitP3E2|type=output name=maxHitP3E2|type=output name=averageHitP3E2|type=output name=damageIncreaseP3E2|type=output 3 1 name=minHitP3E1|type=output name=maxHitP3E1|type=output name=averageHitP3E1|type=output name=damageIncreaseP3E1|type=output 3 0 name=minHitP3E0|type=output name=maxHitP3E0|type=output name=averageHitP3E0|type=output name=damageIncreaseP3E0|type=output 2 4 name=minHitP2E4|type=output name=maxHitP2E4|type=output name=averageHitP2E4|type=output name=damageIncreaseP2E4|type=output 2 3 name=minHitP2E3|type=output name=maxHitP2E3|type=output name=averageHitP2E3|type=output name=damageIncreaseP2E3|type=output 2 2 name=minHitP2E2|type=output name=maxHitP2E2|type=output name=averageHitP2E2|type=output name=damageIncreaseP2E2|type=output 2 1 name=minHitP2E1|type=output name=maxHitP2E1|type=output name=averageHitP2E1|type=output name=damageIncreaseP2E1|type=output 2 0 name=minHitP2E0|type=output name=maxHitP2E0|type=output name=averageHitP2E0|type=output name=damageIncreaseP2E0|type=output 1 4 name=minHitP1E4|type=output name=maxHitP1E4|type=output name=averageHitP1E4|type=output name=damageIncreaseP1E4|type=output 1 3 name=minHitP1E3|type=output name=maxHitP1E3|type=output name=averageHitP1E3|type=output name=damageIncreaseP1E3|type=output 1 2 name=minHitP1E2|type=output name=maxHitP1E2|type=output name=averageHitP1E2|type=output name=damageIncreaseP1E2|type=output 1 1 name=minHitP1E1|type=output name=maxHitP1E1|type=output name=averageHitP1E1|type=output name=damageIncreaseP1E1|type=output 1 0 name=minHitP1E0|type=output name=maxHitP1E0|type=output name=averageHitP1E0|type=output name=damageIncreaseP1E0|type=output 0 4 name=minHitP0E4|type=output name=maxHitP0E4|type=output name=averageHitP0E4|type=output name=damageIncreaseP0E4|type=output 0 3 name=minHitP0E3|type=output name=maxHitP0E3|type=output name=averageHitP0E3|type=output name=damageIncreaseP0E3|type=output 0 2 name=minHitP0E2|type=output name=maxHitP0E2|type=output name=averageHitP0E2|type=output name=damageIncreaseP0E2|type=output 0 1 name=minHitP0E1|type=output name=maxHitP0E1|type=output name=averageHitP0E1|type=output name=damageIncreaseP0E1|type=output 0 0 name=minHitP0E0|type=output name=maxHitP0E0|type=output name=averageHitP0E0|type=output name=damageIncreaseP0E0|type=output

Sources

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
	Rumbling components	Rare	0	1	2	2	2–3	0	1	1	2	2	2–3	3	3–4	4
	Timeworn components	Ancient	0	0	0	0	0	1	1–2	1–2	2–3	2–4	2–4	2–4	2–4	3–4
	Delicate parts	Common	0	0	0	1	1	0	0	0	0	1	1	1	1	1–2
	Precise components	Uncommon	0	1	1–2	1–2	1–2	0	1	1	1–2	1–2	1–2	1–3	1–3	1–4
	Smooth parts	Common	0	0	0	1	1	0	0	0	0	1	1	1	1	1–2

Suggested gizmos

Gizmo layout	Possible perks
	Precise 4–6 (6 is very rare) Equilibrium 2 Other possible perks: Blunted Cautious Flanking Open in calculator: Ancient weapon
	Precise 6 Equilibrium 1–2 Other possible perks: Blunted Cautious Flanking Open in calculator: Ancient weapon
	Precise 6 Ruthless 1 Equilibrium 1–2 Open in calculator: Ancient weapon
	Chance increases with at level 120. 95.93% chance for just Equilibrium 4 at level 120, 92.96% with Equilibrium 4 Ruthless 3 Open in calculator: Ancient weapon
	Equilibrium 2–3 Open in calculator: Weapon
	Equilibrium 1–2 Precise 2–5 Other possible perks: Blunted Cautious Flanking Open in calculator: Weapon
	Equilibrium 1–2 Precise 1–4 (4 is rare) Other possible perks: Blunted Cautious Flanking Open in calculator: Weapon

Update history

The update history project is a work-in-progress – not all updates to this topic may be covered below. See here for how to help out!

• patch 20 March 2017 (Update):
  • Players are once again able to correctly land a critical strike with the Onslaught, Tuska's Wrath and Shadow Tendrils abilities if using the equilibrium perk.

• 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.

• patch 18 April 2016 (Update):
  • Changed the tooltip wording for the equilibrium perk.

• patch 22 February 2016 (Update):
  • The Equilibrium perk now decreases max hit by 1% (down from 3%) per rank. The minimum hit increase remains unchanged.