RuneScape Wiki

Welcome to the RuneScape Wiki! Create an account and join the community!

READ MORE

RuneScape Wiki
Advertisement
RuneScape Wiki
RuneScape Wiki
44,138
pages
in: Perks, Pages that use a deprecated format of the math tags

Precise

Sign in to edit
This article is about the invention perk. For the invention material, see Precise components.
Precise
Description?
Increases your minimum damage by 1.5% per rank of your maximum damage.
Release date 25 January 2016 (Update)
Gizmo type Weapon
Maximum rank 5

Precise is an Invention perk that increases the minimum hit of abilities and autoattacks by a percentage of its max hit. It can be created in weapon gizmos. Damage-over-time abilities are not affected by Precise.

Calculations[]

Average hit formula
  • Without Precise:
  • With Precise:
  • Average hit increase formula:
Notes
  • = Minimum ability damage
  • = Maximum ability damage
  • = rank of the precise perk
  • = Average hit increase
Examples
  • Average hit increase for Slice (damage range 30–120%) with Precise 5:

P4E2 and P5E1[]

An endgame weapon perk setup includes P4E2 or P5E1 perk on off-hand or 2h weapon. This is ~1% damage over Precise 5.

For example, Staff of Sliske with Aftershock 3+Invigorating1, and Precise4Equilibrium2 is best in slot for magic 2h weapons. P4E2 is more ideal than P5E1 for magic due to 4 tick autoattacks. P5E1 is the best of the best for Range and Melee.

Only attempt these endgame gizmos at 120 invention. They are incredibly rare and expensive. Many players sink 400mil-3bil into a few gizmos. Until then, Precise 5 is absolutely fine.

There are two ideal ways to P4E2:

5 Precise[]

1 Armadyl 4 Precise[]

1 Armadyl 4 Precise is the best way to obtain P5E1. This is best of the best perk for Range and Melee. It is even more rare and expensive than P4E2. Very few exist in the game.

Analysis[]

Typically, abilities have ability damage ranges from 20% to 100%; this can be represented as a ratio 1:5. As an example, Havoc's ability damage range is 25–125%; this can be calculated as 20–100%, as the percentage range ratio is 1:5.

As such, Precise increases the ability damage of abilities with a 1:5 ratio as follows:

Rank Increase Avg hit Avg hit increase
N/A 0.0% 60% 0%
1 1.5% 60.75% 1.25%
2 3.0% 61.5% 2.5%
3 4.5% 62.25% 3.75%
4 6.0% 63% 5%
5 7.5% 63.75% 6.25%
  • The table above applies to abilities with a damage range of 20% - 100%, excluding Dismember. The average hit of abilities which cause bleeds are calculated with a different formula; furthermore they are unaffected by the damage increase of Invention perks.

The table below lists the Average hit increase of abilities that have a different ratio of ability damage.

Skill Ability Min hit (Normal) Min hit (Precise 5) Max hit Average hit (Normal) Average hit (Precise 5) Average hit increase
Attack
Slice 30% 39% 120% 75% 79.5% 6%
Slice (Stun) 80% 90.95% 146% 113% 118.475% 4.845%
Overpower 200% 230% 400% 300% 315% 5%
Strength
Hurricane 84% 96.08% 161% 122.5% 128.54% 4.93%
Hurricane (Adjacent) 66% 82.43% 219% 142.5% 150.71% 5.76%
Meteor Strike 250% 276.25% 350% 300% 313.125% 4.375%
Pulverise 250% 276.25% 350% 300% 313.125% 4.375%
Frenzy (Hit #1) 80% 93.5% 180% 130% 136.75% 5.19%
Frenzy (Hit #2) 90% 105% 200% 145% 152.5% 5.17%
Frenzy (Hit #3) 100% 116.5% 220% 160% 168.25% 5.16%
Frenzy (Hit #4) 110% 128% 240% 175% 184% 5.14%
Ranged
Snap Shot (Hit #1) 100% 109% 120% 110% 114.5% 4.09%
Snap Shot (Hit #2) 100% 115.75% 210% 155% 162.88% 5.08%
Snipe 125% 141.43% 219% 172% 180.21% 4.77%
Incendiary Shot 250% 276.25% 350% 300% 313.13% 4.38%
Shadow Tendrils (Self) 33% 51.75% 250% 141.5% 150.88% 6.63%
Shadow Tendrils (Enemy) 66% 103.5% 500% 283% 301.75% 6.63%
Magic
Omnipower 200% 230% 400% 300% 315% 5%
Detonate 100% 126.25% 350% 225% 238.13% 5.84%
Tsunami 200% 222.50% 300% 250% 261.25% 4.5%
Constitution
Storm Shards &
Shatter (1 stack) 		75% 82.125% 95% 85% 88.5625% 4.19%
Onslaught (Hit #1) 33% 44.25% 150% 91.5% 97.13% 6.15%
Onslaught (Hit #2) 44% 57.73% 183% 113.5% 120.36% 6.05%
Onslaught (Hit #3) 55% 71.20% 216% 135.5% 143.6% 5.98%
Onslaught (Hit #4) 66% 84.68% 249% 157.5% 166.84% 5.93%
Onslaught (Hit #5) 77% 98.15% 282% 179.5% 190.08% 5.89%
Onslaught (Hit #6) 88% 111.63% 315% 201.5% 213.31% 5.86%
Onslaught (Hit #7) 99% 125.10% 348% 223.5% 236.55% 5.84%
Onslaught (Hit #8) 110% 138.58% 381% 245.5% 259.79% 5.82%
Onslaught (Hit #9) 121% 152.05% 414% 267.5% 283.03% 5.8%
Onslaught (Hit #10) 132% 165.53% 447% 289.5% 306.26% 5.79%
Onslaught (Hit #11) 143% 179% 480% 311.5% 329.5% 5.78%
Onslaught (Hit #12) 154% 192.48% 513% 333.5% 352.74% 5.77%

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

 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. = 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[]

MaterialRarityPerk ranks with X materials
12345
Armadyl componentsRare12345
Precise componentsUncommon01–21–21–31–4
Connector partsCommon0011–21–2

Suggested gizmos[]

Gizmo layout Possible perks
  • Precise 5
  • Other possible perks:
  • Other possible perks:
v • d • e
Invention perks
Abilities
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
    • Community content is available under CC-BY-SA unless otherwise noted.
    More Fandoms
    Advertisement