Biting

Biting

Description^?
+2% chance per rank to critically hit opponents.
Release date	25 January 2016 (Update)
Gizmo type	Weapon, Armour
Maximum rank	3
Template links
Infobox • Talk page

Biting is an Invention perk that has a 2% chance per rank to force each ability and autoattack to become a critical hit. It can be created in weapon and armour gizmos. As damage-over-time abilities cannot be critical hits, Biting has no effect on them.

Biting does not stack with the set effect of Warpriest of Tuska armour. Additionally, the set effect takes priority over the perk, regardless which effect is greater.

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

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

Perk comparison[edit source]

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[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. 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. = 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
	Direct components	Uncommon	0	1	1–2	1–2	1–3
	Noxious components	Rare	0	1	2	2	3
	Blade parts	Common	0	0	1	1	1–2

Suggested gizmos[edit | edit source]

Gizmo layout

Possible perks

Biting 3

Biting 1–2
Venomblood (very rare)

Other possible perks:

Biting 1–2
Reflexes

Other possible perks:

Cautious

Biting 1–2
Mobile (rare)

Other possible perks:

Biting 1–2
Mobile (rare)

Other possible perks:

Biting 1–2
Genocidal

Other possible perks:

v • d • e 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

Biting

Contents

Analysis[edit | edit source]

Perk comparison[edit source]

Calculator[edit source]

Sources[edit | edit source]

Suggested gizmos[edit | edit source]

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Guides

Databases

Editing

Community

More RuneScape

Tools