FANDOM


This article is about the invention perk. For the invention material, see Precise components.
Precise
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 an ability by a percentage of its max hit.

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

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

Head over to the calculator page for more documentation. Most abilities' min hits are 20% of their max hit, but some abilities also mention min hits. In that case, you can change the min and max hit numbers, but leaving them between 20% and 100% gives correct damage increase numbers for most abilities.

Precise Rank name=precRank1|type=int|range=0,5
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. Yes check = 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.")

}

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


SourcesEdit

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

Suggested gizmosEdit

Gizmo layout Possible perks
Armadyl components
Armadyl componentsArmadyl componentsArmadyl components
Armadyl components
  • Precise Precise 5
Armadyl components
Precise componentsPrecise componentsPrecise components
Precise components
  • Other possible perks:
Precise components
Precise componentsPrecise componentsPrecise components
Precise components
  • Other possible perks:

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.