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 |
let(precRank, precRank1) let(eqRank, eqRank1) let(bitRank, bitRank1) let(minHit, abilityMinHitIn1) let(maxHit, abilityMaxHitIn1) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, 0)
if(minHit < maxHit){
let(minHit, minHit + 0.015 * precRank * maxHit)
let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn1 - minHit))
let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000)
let(normalAverageHitOut1, normalAverageHit) let(abilityMinHitOut1, minHit) let(abilityMaxHitOut1, maxHit) let(perkAverageHitOut1, perkAverageHit) let(percentIncreaseOut1, damageIcrease) let(wrongInput1, "")
}{
let(normalAverageHitOut1, 60) let(abilityMinHitOut1, 20) let(abilityMaxHitOut1, 100) let(perkAverageHitOut1, 60) let(percentIncreaseOut1, 0) let(wrongInput1, "Please give a correct minimum and maximum ability damage.")
}
Full table of Biting Precise and Equilibrium Combinations | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
List of damage increases for various precise and equilibrium combinations, given a certain rank of biting. If you want to sort the tables by damage increase, note that you need to refresh the page for them to re-sort if you change the biting rank. = perks you can get on one gizmo.
type=button|sublist=init|value=Calculate
name=wrongInput2|type=output
init|
let(precRank, 5) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, 0) if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(normalAverageHitOut2, normalAverageHit) let(minHitP5E3, minHit) let(maxHitP5E3, maxHit) let(averageHitP5E3, perkAverageHit) let(damageIncreaseP5E3, damageIcrease) let(wrongInput2, "") }{ let(normalAverageHitOut2, 60) let(minHitP5E3, 20) let(maxHitP5E3, 100) let(averageHitP5E3, 60) let(damageIncreaseP5E3, 0) let(wrongInput2, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP5E2, minHit) let(maxHitP5E2, maxHit) let(averageHitP5E2, perkAverageHit) let(damageIncreaseP5E2, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP5E2, 20) let(maxHitP5E2, 100) let(averageHitP5E2, 60) let(damageIncreaseP5E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP5E1, minHit) let(maxHitP5E1, maxHit) let(averageHitP5E1, perkAverageHit) let(damageIncreaseP5E1, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP5E1, 20) let(maxHitP5E1, 100) let(averageHitP5E1, 60) let(damageIncreaseP5E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP5E0, minHit) let(maxHitP5E0, maxHit) let(averageHitP5E0, perkAverageHit) let(damageIncreaseP5E0, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP5E0, 20) let(maxHitP5E0, 100) let(averageHitP5E0, 60) let(damageIncreaseP5E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP4E3, minHit) let(maxHitP4E3, maxHit) let(averageHitP4E3, perkAverageHit) let(damageIncreaseP4E3, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP4E3, 20) let(maxHitP4E3, 100) let(averageHitP4E3, 60) let(damageIncreaseP4E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP4E2, minHit) let(maxHitP4E2, maxHit) let(averageHitP4E2, perkAverageHit) let(damageIncreaseP4E2, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP4E2, 20) let(maxHitP4E2, 100) let(averageHitP4E2, 60) let(damageIncreaseP4E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP4E1, minHit) let(maxHitP4E1, maxHit) let(averageHitP4E1, perkAverageHit) let(damageIncreaseP4E1, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP4E1, 20) let(maxHitP4E1, 100) let(averageHitP4E1, 60) let(damageIncreaseP4E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP4E0, minHit) let(maxHitP4E0, maxHit) let(averageHitP4E0, perkAverageHit) let(damageIncreaseP4E0, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP4E0, 20) let(maxHitP4E0, 100) let(averageHitP4E0, 60) let(damageIncreaseP4E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP3E3, minHit) let(maxHitP3E3, maxHit) let(averageHitP3E3, perkAverageHit) let(damageIncreaseP3E3, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP3E3, 20) let(maxHitP3E3, 100) let(averageHitP3E3, 60) let(damageIncreaseP3E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP3E2, minHit) let(maxHitP3E2, maxHit) let(averageHitP3E2, perkAverageHit) let(damageIncreaseP3E2, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP3E2, 20) let(maxHitP3E2, 100) let(averageHitP3E2, 60) let(damageIncreaseP3E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP3E1, minHit) let(maxHitP3E1, maxHit) let(averageHitP3E1, perkAverageHit) let(damageIncreaseP3E1, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP3E1, 20) let(maxHitP3E1, 100) let(averageHitP3E1, 60) let(damageIncreaseP3E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP3E0, minHit) let(maxHitP3E0, maxHit) let(averageHitP3E0, perkAverageHit) let(damageIncreaseP3E0, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP3E0, 20) let(maxHitP3E0, 100) let(averageHitP3E0, 60) let(damageIncreaseP3E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP2E3, minHit) let(maxHitP2E3, maxHit) let(averageHitP2E3, perkAverageHit) let(damageIncreaseP2E3, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP2E3, 20) let(maxHitP2E3, 100) let(averageHitP2E3, 60) let(damageIncreaseP2E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP2E2, minHit) let(maxHitP2E2, maxHit) let(averageHitP2E2, perkAverageHit) let(damageIncreaseP2E2, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP2E2, 20) let(maxHitP2E2, 100) let(averageHitP2E2, 60) let(damageIncreaseP2E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP2E1, minHit) let(maxHitP2E1, maxHit) let(averageHitP2E1, perkAverageHit) let(damageIncreaseP2E1, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP2E1, 20) let(maxHitP2E1, 100) let(averageHitP2E1, 60) let(damageIncreaseP2E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP2E0, minHit) let(maxHitP2E0, maxHit) let(averageHitP2E0, perkAverageHit) let(damageIncreaseP2E0, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP2E0, 20) let(maxHitP2E0, 100) let(averageHitP2E0, 60) let(damageIncreaseP2E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP1E3, minHit) let(maxHitP1E3, maxHit) let(averageHitP1E3, perkAverageHit) let(damageIncreaseP1E3, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP1E3, 20) let(maxHitP1E3, 100) let(averageHitP1E3, 60) let(damageIncreaseP1E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP1E2, minHit) let(maxHitP1E2, maxHit) let(averageHitP1E2, perkAverageHit) let(damageIncreaseP1E2, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP1E2, 20) let(maxHitP1E2, 100) let(averageHitP1E2, 60) let(damageIncreaseP1E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP1E1, minHit) let(maxHitP1E1, maxHit) let(averageHitP1E1, perkAverageHit) let(damageIncreaseP1E1, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP1E1, 20) let(maxHitP1E1, 100) let(averageHitP1E1, 60) let(damageIncreaseP1E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP1E0, minHit) let(maxHitP1E0, maxHit) let(averageHitP1E0, perkAverageHit) let(damageIncreaseP1E0, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP1E0, 20) let(maxHitP1E0, 100) let(averageHitP1E0, 60) let(damageIncreaseP1E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP0E3, minHit) let(maxHitP0E3, maxHit) let(averageHitP0E3, perkAverageHit) let(damageIncreaseP0E3, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP0E3, 20) let(maxHitP0E3, 100) let(averageHitP0E3, 60) let(damageIncreaseP0E3, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP0E2, minHit) let(maxHitP0E2, maxHit) let(averageHitP0E2, perkAverageHit) let(damageIncreaseP0E2, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP0E2, 20) let(maxHitP0E2, 100) let(averageHitP0E2, 60) let(damageIncreaseP0E2, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP0E1, minHit) let(maxHitP0E1, maxHit) let(averageHitP0E1, perkAverageHit) let(damageIncreaseP0E1, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP0E1, 20) let(maxHitP0E1, 100) let(averageHitP0E1, 60) let(damageIncreaseP0E1, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
if(minHit < maxHit){ let(minHit, minHit + 0.015 * precRank * maxHit) let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit)) let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit)) let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(bitAverageHit, minHit + 0.975 * (maxHit - minHit)) let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit) let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100) let(normalAverageHit, round(normalAverageHit * 1000)) let(normalAverageHit, normalAverageHit / 1000) let(minHit, round(minHit * 1000)) let(minHit, minHit / 1000) let(maxHit, round(maxHit * 1000)) let(maxHit, maxHit / 1000) let(perkAverageHit, round(perkAverageHit * 1000)) let(perkAverageHit, perkAverageHit / 1000) let(damageIcrease, round(damageIcrease * 1000)) let(damageIcrease, damageIcrease / 1000) let(n, normalAverageHit) let(minHitP0E0, minHit) let(maxHitP0E0, maxHit) let(averageHitP0E0, perkAverageHit) let(damageIncreaseP0E0, damageIcrease) let(n, "") }{ let(n, 60) let(minHitP0E0, 20) let(maxHitP0E0, 100) let(averageHitP0E0, 60) let(damageIncreaseP0E0, 0) let(n, "Please give a correct minimum and maximum ability damage.") }
|
Calculator:Biting Precise and Equilibrium/Doc