Precise

From the RuneScape Wiki, the wiki for all things RuneScape
Jump to navigation Jump to search

Precise is an perk made with Invention that increases the minimum hit of most abilities and auto-attacks by a percentage of their maximum hits. It can be created in regular and ancient weapon gizmos. Damage-over-time abilities (except Bloat) and conjured spirits are not affected by Precise.

Calculations[edit | edit source]

Average hit formula
  • Without Precise:
M+m2=a
  • With Precise:
M+(m+(r1.5%M))2=A
  • Average hit increase formula:
Aaa=aincrease
Notes
  • m = Minimum ability damage
  • M = Maximum ability damage
  • r = rank of the precise perk
  • aincrease = Average hit increase
Examples
  • Average hit increase for Slice (damage range 95–115%) with Precise 6:
a=115%+95%2=105%
A=115%+(95%+(61.5%115%))2=110.175%
aincrease=110.175%105%105%=4.929%

Optimal ancient gizmo combinations[edit | edit source]

An ideal ancient weapon gizmo for off-hand and two-handed weapons contains one of the following perk combinations:

  • Precise 6 and Eruptive 2 (P6E2)
  • Precise 6 and Eruptive 1 (P6E1)
  • Precise 6 and Aftershock 1 (P6AS1)
  • Precise 6 and Ruthless 1 (P6R1)

These combinations give approximately 1% more damage than a common Precise 6 and Genocidal (P6Geno) gizmo.

  • P6E1 is slightly better than P6R1.
  • P6AS1 is ideal for maintaining aftershock stacks.
  • P6R1 is ideal for large amounts of weak monsters.

The suggested combination for P6E2 is 5 Precise components and 4 Armadyl components. For P6AS1, use 7 Armadyl components and 2 Ilujankan components. For P6R1, use 7 Armadyl components and 2 Timeworn components. For P6Geno, use 9 Historic components. Since these gizmos are very rare (and thus expensive), it is recommended to attain level 120 Invention and to drink an extreme invention potion (or super invention for players with lower Herblore) before attempting them. As the damage increase is small, it may be more cost effective to improve gear in other areas before pursuing these combination gizmos.

Regular gizmo combinations[edit | edit source]

An ideal weapon gizmo for off-hand and two-handed weapons contains one of the following perk combinations:

  • Precise 4 and Eruptive 2 (P4E2)
  • Precise 5 and Eruptive 1 (P5E1)

These combinations give approximately 1% more damage than a common Precise 5 or Precise 3 and Eruptive 2 gizmos.

  • P4E2 is slightly better than P5E1 for Magic due to four-tick auto attacks.
  • P5E1 is ideal for Ranged and melee.

The suggested combination for P4E2 is 5 Precise components. For P5E1, use 2 Precise components and 3 Armadyl components. Since these gizmos are very rare (and thus expensive), it is recommended to attain level 120 Invention and to drink an extreme invention potion (or super invention for players with lower Herblore) before attempting them. As the damage increase is small, it may be more cost effective to improve gear in other areas before pursuing these combination gizmos.

Analysis[edit | edit source]

Typically, abilities have ability damage ranges from 90% to 110% of their average damage, this can be represented as a ratio of 9:11, with some abilities rounding to the nearest multiple of 5%. As an example, Wrack's ability damage range is 90–110%, while Slice's damage range is 95-115%. The latter uses approximately the same ratio, but rounds to a multiple of 5%. However, Defence abilities (Bash and Debilitate are the only ones that deal damage) have a 1:5 ratio and deal 20%-100% damage.

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

Rank Increase Avg hit Avg hit increase
N/A 0.0% 100% 0%
1 1.5% 100.825% 0.825%
2 3.0% 101.65% 1.65%
3 4.5% 102.475% 2.475%
4 6.0% 103.3% 3.3%
5 7.5% 104.125% 4.125%
6 9.0% 104.95% 4.95%

Calculator[edit source]

See the calculator page for more documentation.

This calculator is for determining the percent increase from the Precise. Only ability damage range percents are taken into consideration.

Most abilities have a minimum hit of approximately 90% of the average and a maximum hit of 110% of the average, or a minimum hit of 81.8% (the exact ratio is 9/11) of the maximum hit. A lot of abilities have rounding: for example Slice deals 95%-115% ability damage (average of 105%) rather than 94.5%-115.5%.

Many sources of damage (such as bleeds, poison, Aftershock, Summoning familiars, Crackling and Necromancy conjures) are unaffected by Precise. For that reason, the damage increases shown in this calculator will likely be higher than the overall damage increase seen during combat.

Precise rank name=precRank1|type=int|range=0,6|sublist=init
Min hit of ability name=abilityMinHitIn1|type=number|range=0,2000|value=90|sublist=init
Max hit of ability name=abilityMaxHitIn1|type=number|range=0,2000|value=110|sublist=init
Average hit without Precise name=normalAverageHitOut1|type=output
Min hit with Precise (no crit) name=abilityMinHitOut1|type=output
Max hit with Precise (no crit) name=abilityMaxHitOut1|type=output
Average hit with Precise name=perkAverageHitOut1|type=output
% damage increase from Precise name=percentIncreaseOut1|type=output
type=button|sublist=init|value=Calculate
name=wrongInput1|type=output
init|

let(precRank, precRank1) let(minHit, abilityMinHitIn1) let(maxHit, abilityMaxHitIn1) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(normalAverageHitOut1, normalAverageHit)
   let(abilityMinHitOut1, minHit)
   let(abilityMaxHitOut1, maxHit)
   let(perkAverageHitOut1, perkAverageHit)
   let(percentIncreaseOut1, damageIncrease)
   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 Precise ranks

List of damage increases for Precise ranks.

Min hit of ability name=abilityMinHitIn2|type=number|range=0,2000|value=90|sublist=init
Max hit of ability name=abilityMaxHitIn2|type=number|range=0,2000|value=110|sublist=init
Average hit without Precise name=normalAverageHitOut2|type=output
type=button|sublist=init|value=Calculate
name=wrongInput2|type=output
init|

let(precRank, 6) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(normalAverageHitOut2, normalAverageHit)
   let(minHitP6, minHit)
   let(maxHitP6, maxHit)
   let(averageHitP6, perkAverageHit)
   let(damageIncreaseP6, damageIncrease)
   let(wrongInput2, "")

}{

   let(normalAverageHitOut2, 60)
   let(minHitP6, 20)
   let(maxHitP6, 100)
   let(averageHitP6, 60)
   let(damageIncreaseP6, 0)
   let(wrongInput2, "Please give a correct minimum and maximum ability damage.")

}


let(precRank, 5) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(n, normalAverageHit)
   let(minHitP5, minHit)
   let(maxHitP5, maxHit)
   let(averageHitP5, perkAverageHit)
   let(damageIncreaseP5, damageIncrease)
   let(n, "")

}{

   let(n, 60)
   let(minHitP5, 20)
   let(maxHitP5, 100)
   let(averageHitP5, 60)
   let(damageIncreaseP5, 0)
   let(n, "Please give a correct minimum and maximum ability damage.")

}


let(precRank, 4) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(n, normalAverageHit)
   let(minHitP4, minHit)
   let(maxHitP4, maxHit)
   let(averageHitP4, perkAverageHit)
   let(damageIncreaseP4, damageIncrease)
   let(n, "")

}{

   let(n, 60)
   let(minHitP4, 20)
   let(maxHitP4, 100)
   let(averageHitP4, 60)
   let(damageIncreaseP4, 0)
   let(n, "Please give a correct minimum and maximum ability damage.")

}


let(precRank, 3) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(n, normalAverageHit)
   let(minHitP3, minHit)
   let(maxHitP3, maxHit)
   let(averageHitP3, perkAverageHit)
   let(damageIncreaseP3, damageIncrease)
   let(n, "")

}{

   let(n, 60)
   let(minHitP3, 20)
   let(maxHitP3, 100)
   let(averageHitP3, 60)
   let(damageIncreaseP3, 0)
   let(n, "Please give a correct minimum and maximum ability damage.")

}


let(precRank, 2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(n, normalAverageHit)
   let(minHitP2, minHit)
   let(maxHitP2, maxHit)
   let(averageHitP2, perkAverageHit)
   let(damageIncreaseP2, damageIncrease)
   let(n, "")

}{

   let(n, 60)
   let(minHitP2, 20)
   let(maxHitP2, 100)
   let(averageHitP2, 60)
   let(damageIncreaseP2, 0)
   let(n, "Please give a correct minimum and maximum ability damage.")

}


let(precRank, 1) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(n, normalAverageHit)
   let(minHitP1, minHit)
   let(maxHitP1, maxHit)
   let(averageHitP1, perkAverageHit)
   let(damageIncreaseP1, damageIncrease)
   let(n, "")

}{

   let(n, 60)
   let(minHitP1, 20)
   let(maxHitP1, 100)
   let(averageHitP1, 60)
   let(damageIncreaseP1, 0)
   let(n, "Please give a correct minimum and maximum ability damage.")

}


let(precRank, 0) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2)

if(minHit < maxHit){

   let(minHit, minHit + 0.015 * precRank * maxHit)
   let(perkAverageHit, (maxHit + minHit) / 2)
   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
   let(damageIncrease, damageIncrease / 1000)
   let(n, normalAverageHit)
   let(minHitP0, minHit)
   let(maxHitP0, maxHit)
   let(averageHitP0, perkAverageHit)
   let(damageIncreaseP0, damageIncrease)
   let(n, "")

}{

   let(n, 60)
   let(minHitP0, 20)
   let(maxHitP0, 100)
   let(averageHitP0, 60)
   let(damageIncreaseP0, 0)
   let(n, "Please give a correct minimum and maximum ability damage.")

}

Precise rank Min hit Max hit Average Hit % damage
increase
6 name=minHitP6|type=output name=maxHitP6|type=output name=averageHitP6|type=output name=damageIncreaseP6|type=output
5 name=minHitP5|type=output name=maxHitP5|type=output name=averageHitP5|type=output name=damageIncreaseP5|type=output
4 name=minHitP4|type=output name=maxHitP4|type=output name=averageHitP4|type=output name=damageIncreaseP4|type=output
3 name=minHitP3|type=output name=maxHitP3|type=output name=averageHitP3|type=output name=damageIncreaseP3|type=output
2 name=minHitP2|type=output name=maxHitP2|type=output name=averageHitP2|type=output name=damageIncreaseP2|type=output
1 name=minHitP1|type=output name=maxHitP1|type=output name=averageHitP1|type=output name=damageIncreaseP1|type=output
0 name=minHitP0|type=output name=maxHitP0|type=output name=averageHitP0|type=output name=damageIncreaseP0|type=output

Sources[edit | edit source]

MaterialRarityPerk ranks with X materials
Standard gizmoAncient gizmo
12345123456789
Armadyl componentsRare1234501–223455–666
Historic componentsAncient0000001–21–31–41–51–61–62–62–6
Precise componentsUncommon01–21–21–31–4011–21–21–31–41–51–51–6
Connector partsCommon0011–21–2000111–21–21–21–3

Suggested gizmos[edit | edit source]

Update history[edit | edit source]

This information has been compiled as part of the update history project. Some updates may not be included – see here for how to help out!
  • patch 29 February 2016 (Update):
    • Abilities no longer suffer the 10k damage cap when using the 'Precise' perk.
  • patch 22 February 2016 (Update):
    • The Precise perk now has an increased minimum damage of 1.5% per rank of your maximum damage, up from 1%.