Equilibrium

Equilibrium

Release date	25 January 2016 (Update)
Gizmo type	Weapon
Maximum rank	3
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.

Damage-over-time 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%

Combining Equilibrium with Precise[edit | edit source]

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[edit | edit source]

Perk comparison[edit source]

For abilities with a damage range 20–100%; a ratio 1:5:

Perk(s)	Avg hit increase
Equilibrium 3, Precise 5	9.875%
Biting 3, Precise 5	9.694%
Precise 5	6.25%
Equilibrium 3	4%
Biting 3	3.80%

Calculator[edit source]

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. Most abilities' min hits are 20% of their max hit, but some abilities also mention min hits. In that case, you can change the min and max hit numbers, but leaving them between 20% and 100% gives correct damage increase numbers for most abilities.

Precise rank	name=precRank1\|type=int\|range=0,5\|sublist=init
Equilibrium rank	name=eqRank1\|type=int\|range=0,3\|sublist=init
Biting rank	name=bitRank1\|type=int\|range=0,3\|sublist=init
Is Biting on level 20 gear?	name=isLevel20_1\|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	name=normalAverageHitOut1\|type=output
Min hit with perks	name=abilityMinHitOut1\|type=output
Max hit with perks	name=abilityMaxHitOut1\|type=output
Average hit with perks	name=perkAverageHitOut1\|type=output
% damage increase from perks	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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(normalAverageHitOut1, normalAverageHit)
   let(abilityMinHitOut1, minHit)
   let(abilityMaxHitOut1, maxHit)
   let(perkAverageHitOut1, perkAverageHit)
   let(percentIncreaseOut1, damageIcrease)
   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. = perks you can get on one gizmo.

Biting Rank	name=bitRank2\|type=int\|range=0,3\|sublist=init
Is Biting on level 20 gear?	name=isLevel20_2\|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	name=normalAverageHitOut2\|type=output

type=button|sublist=init|value=Calculate

name=wrongInput2|type=output

init|

let(precRank, 5) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(normalAverageHitOut2, normalAverageHit)
   let(minHitP5E3, minHit)
   let(maxHitP5E3, maxHit)
   let(averageHitP5E3, perkAverageHit)
   let(damageIncreaseP5E3, damageIcrease)
   let(wrongInput2, "")

}{

   let(normalAverageHitOut2, 60)
   let(minHitP5E3, 20)
   let(maxHitP5E3, 100)
   let(averageHitP5E3, 60)
   let(damageIncreaseP5E3, 0)
   let(wrongInput2, "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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP5E2, minHit)
   let(maxHitP5E2, maxHit)
   let(averageHitP5E2, perkAverageHit)
   let(damageIncreaseP5E2, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP5E1, minHit)
   let(maxHitP5E1, maxHit)
   let(averageHitP5E1, perkAverageHit)
   let(damageIncreaseP5E1, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP5E0, minHit)
   let(maxHitP5E0, maxHit)
   let(averageHitP5E0, perkAverageHit)
   let(damageIncreaseP5E0, damageIcrease)
   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, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP4E3, minHit)
   let(maxHitP4E3, maxHit)
   let(averageHitP4E3, perkAverageHit)
   let(damageIncreaseP4E3, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP4E2, minHit)
   let(maxHitP4E2, maxHit)
   let(averageHitP4E2, perkAverageHit)
   let(damageIncreaseP4E2, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP4E1, minHit)
   let(maxHitP4E1, maxHit)
   let(averageHitP4E1, perkAverageHit)
   let(damageIncreaseP4E1, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP4E0, minHit)
   let(maxHitP4E0, maxHit)
   let(averageHitP4E0, perkAverageHit)
   let(damageIncreaseP4E0, damageIcrease)
   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, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP3E3, minHit)
   let(maxHitP3E3, maxHit)
   let(averageHitP3E3, perkAverageHit)
   let(damageIncreaseP3E3, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP3E2, minHit)
   let(maxHitP3E2, maxHit)
   let(averageHitP3E2, perkAverageHit)
   let(damageIncreaseP3E2, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP3E1, minHit)
   let(maxHitP3E1, maxHit)
   let(averageHitP3E1, perkAverageHit)
   let(damageIncreaseP3E1, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP3E0, minHit)
   let(maxHitP3E0, maxHit)
   let(averageHitP3E0, perkAverageHit)
   let(damageIncreaseP3E0, damageIcrease)
   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, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP2E3, minHit)
   let(maxHitP2E3, maxHit)
   let(averageHitP2E3, perkAverageHit)
   let(damageIncreaseP2E3, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP2E2, minHit)
   let(maxHitP2E2, maxHit)
   let(averageHitP2E2, perkAverageHit)
   let(damageIncreaseP2E2, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP2E1, minHit)
   let(maxHitP2E1, maxHit)
   let(averageHitP2E1, perkAverageHit)
   let(damageIncreaseP2E1, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP2E0, minHit)
   let(maxHitP2E0, maxHit)
   let(averageHitP2E0, perkAverageHit)
   let(damageIncreaseP2E0, damageIcrease)
   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, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP1E3, minHit)
   let(maxHitP1E3, maxHit)
   let(averageHitP1E3, perkAverageHit)
   let(damageIncreaseP1E3, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP1E2, minHit)
   let(maxHitP1E2, maxHit)
   let(averageHitP1E2, perkAverageHit)
   let(damageIncreaseP1E2, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP1E1, minHit)
   let(maxHitP1E1, maxHit)
   let(averageHitP1E1, perkAverageHit)
   let(damageIncreaseP1E1, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP1E0, minHit)
   let(maxHitP1E0, maxHit)
   let(averageHitP1E0, perkAverageHit)
   let(damageIncreaseP1E0, damageIcrease)
   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, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP0E3, minHit)
   let(maxHitP0E3, maxHit)
   let(averageHitP0E3, perkAverageHit)
   let(damageIncreaseP0E3, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP0E2, minHit)
   let(maxHitP0E2, maxHit)
   let(averageHitP0E2, perkAverageHit)
   let(damageIncreaseP0E2, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP0E1, minHit)
   let(maxHitP0E1, maxHit)
   let(averageHitP0E1, perkAverageHit)
   let(damageIncreaseP0E1, damageIcrease)
   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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
   let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)

   let(damageIcrease, (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(damageIcrease, round(damageIcrease * 1000))
   let(damageIcrease, damageIcrease / 1000)

   let(n, normalAverageHit)
   let(minHitP0E0, minHit)
   let(maxHitP0E0, maxHit)
   let(averageHitP0E0, perkAverageHit)
   let(damageIncreaseP0E0, damageIcrease)
   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
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	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	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	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	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	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[edit | edit source]

Material		Rarity	Perk ranks with X materials
Material		Rarity	1	2	3	4	5
	Rumbling components	Rare	0	1	2	2	2–3
	Delicate parts	Common	0	0	0	1	1
	Precise components	Uncommon	0	1	1–2	1–2	1–2
	Smooth parts	Common	0	0	0	1	1

Suggested gizmos[edit | edit source]

Gizmo layout

Possible perks

Equilibrium 2–3 (3 is rare)

Open in calculator:

Weapon

Equilibrium 1–2
Precise 2–5

Other possible perks:

Open in calculator:

Weapon

Equilibrium 1–2
Precise 1–4 (4 is rare)

Other possible perks:

Open in calculator:

Weapon

Update history[edit | edit source]

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 22 February 2016 (Update):
- The Equilibrium perk now decreases max hit by 1% (down from 3%) per rank. The minimum hit increase remains unchanged.

v • d • e RS3 Invention perks
Abilities	Brief Respite Bulwark Caroming Clear Headed Energising Lunging Mobile Planted Feet Preparation Reflexes Shield Bashing Turtling Ultimatums Taunting
Damage/Accuracy modifying	Aftershock Biting Blunted Crackling Demon Bait Demon Slayer Dragon Bait Dragon Slayer Equilibrium Flanking Genocidal Inaccurate Mediocrity Precise Spendthrift Undead Bait Undead Slayer
Damage reduction	Absorbative Crystal Shield Devoted Enhanced Devoted Lucky Venomblood
Adrenaline	Fatiguing Invigorating Impatient
Prayer	Antitheism Profane Hoarding
Additional items	Brassican Looting Scavenging
Experience	Enlightened Tinker Wise
Skilling	Butterfingers Breakdown Charitable Cheapskate Confused Furnace Honed Imp Souled Polishing Pyromaniac Rapid Refined
Miscellaneous	Cautious Committed Efficient Enhanced Efficient Glow Worm Hallucinogenic Junk Food Mysterious Prosper Talking Trophy-taker's

Equilibrium

Contents

Combining Equilibrium with Precise[edit | edit source]

Analysis[edit | edit source]

Perk comparison[edit source]

Calculator[edit source]

Sources[edit | edit source]

Suggested gizmos[edit | edit source]

Update history[edit | edit source]

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Guides

Databases

Editing

Community

More RuneScape

Tools