## FANDOM

39,345 Pages

 Description? Increases your minimum damage by 1.5% per rank of your maximum damage. (Update) Weapon 5

Precise is an Invention perk that increases the minimum hit of an ability by a percentage of its max hit. It can be created in weapon gizmos.

## CalculationsEdit

Average hit formula for abilities, not including bleeds
• Without Precise:
$\frac{M + m}{2} = a$
• With Precise:
$\frac{M + (m + (r \cdot 1.5% \cdot M))}{2} = A$
• Average hit increase formula:
$\frac{A - a}{a} = a_{increase}$
Notes
• $m$ = Minimum ability damage
• $M$ = Maximum ability damage
• $r$ = rank of the precise perk
• $a_{increase}$ = Average hit increase
Examples
• Average hit increase for Slice (damage range 30–120%) with Precise 5:
$a = \frac{120% + 30%}{2} = 75%$
$A = \frac{120% + (30% + (5 \cdot 1.5% \cdot 120%))}{2} = 79.5%$
$a_{increase} = \frac{79.5% - 75%}{75%} = 6%$

## AnalysisEdit

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 comparisonEdit

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%

### CalculatorEdit

 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 Equilibrium Rank name=eqRank1|type=int|range=0,3 Biting Rank name=bitRank1|type=int|range=0,3 Min hit of ability name=abilityMinHitIn1|type=number|range=0,1000|value=20 Max hit of ability name=abilityMaxHitIn1|type=number|range=0,1000|value=100 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)

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(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - 0.02 * bitRank) * (maxHit + minHit) / 2 + 0.02 * bitRank * 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 Min hit of ability name=abilityMinHitIn2|type=number|range=0,1000|value=20 Max hit of ability name=abilityMaxHitIn2|type=number|range=0,1000|value=100 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## SourcesEdit

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

### Suggested gizmosEdit

Gizmo layout Possible perks
• Precise 5
• Other possible perks:
• Other possible perks: