RuneScape Wiki
Register
Advertisement
Biting
Biting
Description?
+2% chance per rank to critically hit opponents.
Release date 25 January 2016 (Update)
Gizmo type Weapon, Armour
Maximum rank 3

Biting is an Invention perk that increases critical hit chance by 2% per rank of the perk. This does not stack with the set effect of Warpriest of Tuska armour. In addition, the set effect will take priority over the perk, regardless of which effect is larger. It can be created in weapon and armour gizmos. As damage-over-time abilities cannot have critical hits, Biting has no affect on these abilities.

When Biting causes a critical hit, the message "You deal a critical strike against your opponent!" appears.

Critical hit chance
Rank Critical hit chance Avg hit increase
1 +2% (2.2%) 1.267% (1.393%)
2 +4% (4.4%) 2.533% (2.786%)
3 +6% (6.6%) 3.8% (4.18%)
  • All numbers in parentheses refer to level 20 gear.

Analysis[]

Perk comparison[]

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

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

Calculator[]

Clockwork
This is a dynamic calculator that requires Javascript.
This takes user input via Javascript, and may use changing prices from the Grand Exchange Market Watch.
If prices appear to be outdated, purge the page by clicking here.

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. If you want to sort the tables by damage increase, note that you need to refresh the page for them to re-sort if you change the biting rank. Yes check = 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.")

}

Yes check P E Min hit Max hit Average Hit % damage
increase
X mark 5 3 name=minHitP5E3|type=output name=maxHitP5E3|type=output name=averageHitP5E3|type=output name=damageIncreaseP5E3|type=output
X mark 5 2 name=minHitP5E2|type=output name=maxHitP5E2|type=output name=averageHitP5E2|type=output name=damageIncreaseP5E2|type=output
Yes check 5 1 name=minHitP5E1|type=output name=maxHitP5E1|type=output name=averageHitP5E1|type=output name=damageIncreaseP5E1|type=output
Yes check 5 0 name=minHitP5E0|type=output name=maxHitP5E0|type=output name=averageHitP5E0|type=output name=damageIncreaseP5E0|type=output
X mark 4 3 name=minHitP4E3|type=output name=maxHitP4E3|type=output name=averageHitP4E3|type=output name=damageIncreaseP4E3|type=output
Yes check 4 2 name=minHitP4E2|type=output name=maxHitP4E2|type=output name=averageHitP4E2|type=output name=damageIncreaseP4E2|type=output
Yes check 4 1 name=minHitP4E1|type=output name=maxHitP4E1|type=output name=averageHitP4E1|type=output name=damageIncreaseP4E1|type=output
Yes check 4 0 name=minHitP4E0|type=output name=maxHitP4E0|type=output name=averageHitP4E0|type=output name=damageIncreaseP4E0|type=output
X mark 3 3 name=minHitP3E3|type=output name=maxHitP3E3|type=output name=averageHitP3E3|type=output name=damageIncreaseP3E3|type=output
Yes check 3 2 name=minHitP3E2|type=output name=maxHitP3E2|type=output name=averageHitP3E2|type=output name=damageIncreaseP3E2|type=output
Yes check 3 1 name=minHitP3E1|type=output name=maxHitP3E1|type=output name=averageHitP3E1|type=output name=damageIncreaseP3E1|type=output
Yes check 3 0 name=minHitP3E0|type=output name=maxHitP3E0|type=output name=averageHitP3E0|type=output name=damageIncreaseP3E0|type=output
X mark 2 3 name=minHitP2E3|type=output name=maxHitP2E3|type=output name=averageHitP2E3|type=output name=damageIncreaseP2E3|type=output
Yes check 2 2 name=minHitP2E2|type=output name=maxHitP2E2|type=output name=averageHitP2E2|type=output name=damageIncreaseP2E2|type=output
Yes check 2 1 name=minHitP2E1|type=output name=maxHitP2E1|type=output name=averageHitP2E1|type=output name=damageIncreaseP2E1|type=output
Yes check 2 0 name=minHitP2E0|type=output name=maxHitP2E0|type=output name=averageHitP2E0|type=output name=damageIncreaseP2E0|type=output
X mark 1 3 name=minHitP1E3|type=output name=maxHitP1E3|type=output name=averageHitP1E3|type=output name=damageIncreaseP1E3|type=output
Yes check 1 2 name=minHitP1E2|type=output name=maxHitP1E2|type=output name=averageHitP1E2|type=output name=damageIncreaseP1E2|type=output
Yes check 1 1 name=minHitP1E1|type=output name=maxHitP1E1|type=output name=averageHitP1E1|type=output name=damageIncreaseP1E1|type=output
Yes check 1 0 name=minHitP1E0|type=output name=maxHitP1E0|type=output name=averageHitP1E0|type=output name=damageIncreaseP1E0|type=output
Yes check 0 3 name=minHitP0E3|type=output name=maxHitP0E3|type=output name=averageHitP0E3|type=output name=damageIncreaseP0E3|type=output
Yes check 0 2 name=minHitP0E2|type=output name=maxHitP0E2|type=output name=averageHitP0E2|type=output name=damageIncreaseP0E2|type=output
Yes check 0 1 name=minHitP0E1|type=output name=maxHitP0E1|type=output name=averageHitP0E1|type=output name=damageIncreaseP0E1|type=output
Yes check 0 0 name=minHitP0E0|type=output name=maxHitP0E0|type=output name=averageHitP0E0|type=output name=damageIncreaseP0E0|type=output


Sources[]

MaterialRarityPerk ranks with X materials
12345
Direct components
Direct componentsUncommon011–21–21–3
Noxious components
Noxious componentsRare01223
Blade parts
Blade partsCommon00111–2

Suggested gizmos[]

Gizmo layout Possible perks
Noxious components
Noxious componentsNoxious componentsNoxious components
Noxious components
  • Biting Biting 3
Evasive components
Direct componentsHealthy componentsDirect components
Direct components
  • Other possible perks:
Direct components
Direct componentsDirect componentsDirect components
Harnessed components
  • Other possible perks:
Direct components
Direct componentsDirect componentsDirect components
Subtle components
  • Other possible perks:
Direct components
Direct componentsDirect componentsDirect components
Dextrous components
  • Other possible perks:
Direct components
Direct componentsDirect componentsBandos components
Undead components
  • Other possible perks:
Advertisement