High potency skills and/or auto-crit/auto-direct-crit

Quote:

---

Originally Posted by Daeriion_Aeradiir

You may still have the same chances on each individual hit, but the amount of damage you'll achieve will be far lower on average than on single hits due to law of statistical averages with higher attempts.

---

This is what we call Gambler's Fallacy.

For example, suppose a fair coin is flipped 100 times. Using the law of averages, one might predict that there will be 50 heads and 50 tails. While this is the single most likely outcome, there is only an 8% chance of it occurring according to P(X=50\mid n=100,p=0.5) of the binomial distribution.

If you read the Law of averages correctly, you'll know that your chance doesn't increase nor reduce with the number of attempt.

For exemple, If you split Double down in 4 hits like you said, you will just roll 4x time more dice but your chance never increase. Let's admit that in the original 1 hit you do 20% crit chance, over a fight you then land 2 Double that are crit when you launch 10 of them.

So, 10 Double down, 2 are crits. Now if we are to increase that to 4x time you do 40 Damage of double down and 8 Crit. See ? 0 Difference (Because your damage, even if they are split will lead to the same result) 1200 x 2 = 300 x 8 = 2400. This will not change also because you still press 10 time one button inside the same window of time. This is called proportionnality. You may see more crit BECAUSE you roll more, but the end result would still be the exact same. More roll dice doesn't affect your crit chance and by extension doesn't touch variance.

To reduce the Variance you need to play with the crit chance or to readapt the potency for every single attack on your jobs to be more equal. Because 1200 x 1.5 (Crit DMG) is clearly more powerful than 300 x 1.5

If you were to have Double down at 15 sec of GCD and 300 potency for 1 hit it would be the exact same because now it's 1200 potency for 60 sec CD. Variance comes from the power of all the attack in total you have and which one is gonna crit and which one won't. If double down was 120 potency 10 times on a single button, that wouldn't change anythin because the button would still be a 1200 Potency value.

So basically, If you are lucky you will kick ass from anything. If you aren't, you will simply have a poor DPS.

TL: DR : Increasing the quantity of roll doesn't increase the chance.

People claiming that what I'm suggesting won't change a thing probably don't understand what I'm actually suggesting. I am suggesting that big damage hits be split into individual hits that each have a chance to crit, this will fix massive crit variance because it effectively reduces your chance to crit your big hits to the same effect.

Let's say, for an example, you hit 100 times during a fight and 4 of those hits are Double Downs and 2 of those Double Downs crit, so the crits on your big hits account for 2% of your total hits during the fight. Now let's say Double Down now hits 3 times, so now you have 4x3=12 hits from Double Down, adjusted total hit count is now 108. Now let's say you want the same total damage that you got from before, you now need to crit 2x3=6 hits from Double Down, which increases the total amount of crits that needs to go into Double Down from 2/100=2% to 6/108=5.56% of total hits.

Whichever way you slice it, it would be a lower chance to get the equivalent results as now, not exactly the same. The percentage only stays the exact same if you triple the hits of everything else in your kit too. If people still think it changes nothing after this, then have it your way, think what you want, I won't bother trying to change your mind.

Quote:

---

Originally Posted by Aravell

People claiming that what I'm suggesting won't change a thing probably don't understand what I'm actually suggesting. I am suggesting that big damage hits be split into individual hits that each have a chance to crit, this will fix massive crit variance because it effectively reduces your chance to crit your big hits to the same effect.

---

There might be a small misunderstanding from looking at the problem in different ways. Breaking up attacks won't change the average damage done over many instances. It does increase the number of possible outcomes for a given attack and some of those new outcomes will deviate less from the average, but it doesn't change the min or max possible variance.

Splitting attacks into multiple parts will mean that any given damage log is more likely to fall closer to the average, but the top 1%/bottom 1% is still going to be biased by luck. If the desire behind breaking up attacks is a very, very slight increase in consistency then it might make sense, but I'm not sure if people will really notice. If the desire is to eliminate or reduce the luck factor inherent in the very best or very worst instances of a raid, the change won't do anything. Forced crits are a better solution in the latter case. They directly reduce variation.

Quote:

---

Originally Posted by PyurBlue

There might be a small misunderstanding from looking at the problem in different ways. Breaking up attacks won't change the average damage done over many instances. It does increase the number of possible outcomes for a given attack and some of those new outcomes will deviate less from the average, but it doesn't change the min or max possible variance.

Splitting attacks into multiple parts will mean that any given damage log is more likely to fall closer to the average, but the top 1%/bottom 1% is still going to be biased by luck. If the desire behind breaking up attacks is a very, very slight increase in consistency then it might make sense, but I'm not sure if people will really notice. If the desire is to eliminate or reduce the luck factor inherent in the very best or very worst instances of a raid, the change won't do anything. Forced crits are a better solution in the latter case. They directly reduce variation.

---

The top 1%/bottom % is basically irrelevant in this scenario. Doesn't really matter if someone gets a god crit/dh once in a single run, it's about creating more consistent damage profiles for the 99% of runs, and tightening the expected damage outcome to a singluar point than allowing it to swing so insanely wildly as it does currently.

Take TOP for example, a fight with notoriously tight dps checks, coupled with short phases making 2mins become a far more important source of damage than in other fights. In phase 1, you only get 1 set of 2mins, meaning any crits/dhs within this single set of 2mins can lead to massively different damage spreads on the boss, purely because they make up a significant chunk of the damage done to the boss during the phase. A single Hyosho from a NIN can do anywhere from close to 100k to an upwards of 300k depending on no other factor than pure luck. My group can go anywhere from seeing halfway through the enrage castbar of phase 1 to having to hold for an upwards of 10s to make sure our 2mins are up for the start of p2 purely on nothing more than CRT/DH rng as a group, which is ridiculous design.


Heck, a variation of this problem was even occurring in TOP's P6 because the insanely high damage hits of Limit Break used to be subjected to a +/- 5% damage range, which meant getting unlucky on enough of the LB rolls would put your group 100-200k damage behind another group that just got lucky, which was the make or break of many groups that weren't ultra top tier when coupled with the phases's tighter than usual dps check. Square solved this by doing the exact same thing several suggestions in this topic are hinting towards - they simply tightened the expected damage values towards a singular point by lowering the possible variance on Limit break skills to +/- 1-2% instead, making LB damage's contribution far more consistent for the phase.

Splitting single huge attacks into multiple instances of damage would in fact creating a far more concentrated, consistent damage profile around a single expected value - purely because outside of a blue moon, no one will be getting lucky enough to hit multiple god rolls for each individual part of the multi-hit on their big skills, while the odds of getting equally unlucky will be insanely low as well. The mins & maxes may not have changed, but getting to them will be statistically rare. The expected average potency of the skill will be more centralized around an expected value instead of wildly ranging from 1200 to an upwards of 2500 depending on statistical odds that are relatively easy to achieve comparatively (6-10% for CRT+DH currently). You can even already see this type of damage philosophy and its expected outcomes on DRK contrasted to a tank like PLD. DRK's Shadowbringer is split into 2 individual 600 potency hits, when coupled with a huge abundance of 460 & 500 ish potency hits from their various OGCDs, makes it so their damage profile is far more spread out and getting the DH/CRIT rng on one skill doesn't influence their damage profile as heavily.

Contrast PLD, where they have such an insane amount of potency funneled into 4 skills that those 4 skills basically dictate the PLD's damage output that particular minute depending on how lucky the PLD gets. For a DRK to get a 'god' damage output, they have to win something like 40-50 damage rolls between all of their OGCDs, GCDs and LS's attacks, making each roll contribute far less to the overall damage profile. PLD only have to win 8 rolls across 4 skills, meaning each roll's outcome causes the final result to swing wildly, positively and negatively.

It's simple mitigation tactics. More rolls = each roll contributes less to the overall result = expected damage fixates upon a singular point than being in a very wildly swinging state and is far easier to be balanced around, while also giving that dopamine hit for the player of getting that ultra rare quad-dh/crit, or even just the dopamine of getting 2-3 parts of your multi-hit attack to crit.

Auto crits do nothing for me, im not fooled by big numbers that are automatically handed to me. I dont understand their approach to big potency abilities anyway, is anyone seriously going to lose sleep over it if we were to go back to more spread out potencies?

Quote:

---

Originally Posted by Daeriion_Aeradiir

The top 1%/bottom % is basically irrelevant in this scenario.

---

If that is not a case of interest, then I can understand the desire for split attacks a little better. However I still think forced crit is a better solution.

Quote:

---

Splitting single huge attacks into multiple instances of damage would in fact creating a far more concentrated, consistent damage profile around a single expected value - purely because outside of a blue moon, no one will be getting lucky enough to hit multiple god rolls for each individual part of the multi-hit on their big skills

---

I'm not sure that the difference would be that much just because of the number of attacks in a given run of anything is fairly high.

Out of curiosity I coded a simulator for the situation we've been discussing and let 1000 instances of 100 big vs 300 small attacks play out and took the max total damage from both. As it turns out, despite the odds, the small attacks gave the highest value. My code is a little sloppy because I did this quick, but if anyone is interested in playing with it or checking it for errors, this can be run in Python:

Code:

---

import random
big = 1200
sml = 400
crit = 0.5
rate = 0.25
crit_set = 0
big_sum = 0
sml_sum = 0
big_list = []
sml_list = []
atk_num = 100
tst_num = 1000

for k in range (tst_num):
    for i in range(atk_num):
    crit_check = random.random()
    #print(crit_check)
    if crit_check > rate:
            crit_set = 0
    else:
        crit_set = 1
        big_damage = big + big* crit * crit_set
        #print(big_damage)
        big_sum = big_sum + big_damage
        #big_average = big_sum/tst_num
        #big_list.append(big_average)
    i = i + 1
    big_average = big_sum/tst_num
    big_list.append(big_average)
    for j in range(atk_num*3):
    crit_check = random.random()
    #print(crit_check)
    if crit_check > rate:
            crit_set = 0
    else:
        crit_set = 1
        sml_damage = sml + sml* crit * crit_set
        #print(sml_damage)
        sml_sum = sml_sum + sml_damage
        sml_average = sml_sum/tst_num
        sml_list.append(sml_average)
    j = j + 1
    sml_average = sml_sum/tst_num
    sml_list.append(sml_average)
#print("Sum of big attacks is ", big_sum)
#print("Sum of small attacks is ", sml_sum)
    big_average = big_sum/tst_num
    big_list.append(big_average)
    sml_average = sml_sum/tst_num
    sml_list.append(sml_average)
    print("List of big attack logs is ", big_average)
    print("List of small attack logs is ", sml_average)
print("Max of big attack logs is ", max(big_list))
print("Max of small attack logs is ", max(sml_list))
#print("big is:", len(big_list))

---

Result:
Max of big attack logs is 44962.2
Max of small attack logs is 45021.6

The fact that the small attacks ended up being larger is a small detail, what's more telling is that they're so close. You could argue that my approach is flawed because this is just the same attack over and over, not a rotation. That is a limitation with my method that might skew results.

Edit
Code needs fixing, I tested it again and noticed that it's not making a list of averages, so it's actually just printing the last values. I was hoping this would be quick, but code never is. Sorry.

Quote:

---

Originally Posted by PyurBlue

Out of curiosity I coded a simulator for the situation we've been discussing and let 1000 instances of 100 big vs 300 small attacks play out and took the max total damage from both. As it turns out, despite the odds, the small attacks gave the highest value. My code is a little sloppy because I did this quick, but if anyone is interested in playing with it or checking it for errors, this can be run in Python:

...

Result:
Max of big attack logs is 44962.2
Max of small attack logs is 45021.6

The fact that the small attacks ended up being larger is a small detail, what's more telling is that they're so close. You could argue that my approach is flawed because this is just the same attack over and over, not a rotation. That is a limitation with my method that might skew results.

---

Errr… 100 big hits should be at least 100 * 1200 = 120,000 damage. Due to indentation errors, I think you're summing only the critical hits. And I think you're not resetting some variables between loop iterations?

Fixing the errors (I hope)…

Code:

---

import random
import statistics

big = 1200
sml = 400
crit = 0.5
rate = 0.25
big_list = []
sml_list = []

for _run_id in range(1_000_000):

    big_damage = 0
    for _atk_id in range(100):
        big_damage += big + big * crit * (1 if random.random() < rate else 0)
    big_list.append(big_damage)

    sml_damage = 0
    for _akt_id in range(300):
        sml_damage += sml + sml * crit * (1 if random.random() < rate else 0)
    sml_list.append(sml_damage)

print("-" * 40)
print("[100 big hits] Average total damage:", statistics.mean(big_list))
print("[100 big hits] Maximum total damage:", max(big_list))
print("[100 big hits] Variance:", statistics.pvariance(big_list))
print("-" * 40)
print("[300 small hits] Average total damage:", statistics.mean(sml_list))
print("[300 small hits] Maximum total damage:", max(sml_list))
print("[300 small hits] Variance:", statistics.pvariance(sml_list))

---

After running each scenario one million times:

[100 big hits] Average total damage: 135000.0018
[100 big hits] Maximum total damage: 148200.0
[100 big hits] Variance: 6750386.27999676
----------------------------------------
[300 small hits] Average total damage: 135002.1402
[300 small hits] Maximum total damage: 143600.0
[300 small hits] Variance: 2253780.41954396

The average total damage is the same between the two scenarios, and exactly what it should be: 135000 = 100 * (1200 * (1 - 0.25) + 1200 * 1.5 * 0.25).

The variance is lower for the scenario where we use smaller hits, which explains why the maximum total damage of the smaller hits scenario is slightly lower.

Quote:

---

Originally Posted by AmiableApkallu

Errr… 100 big hits should be at least 100 * 1200 = 120,000 damage. Due to indentation errors, I think you're summing only the critical hits. And I think you're not resetting some variables between loop iterations?

---

Thanks for double checking. Yes, I was forgetting to reset variables and probably had the indentations incorrect as well. I started over and I'm also seeing lower maximums with small hits now:

Code:

---

import random
big = 1200
sml = 400
crit = 0.5
rate = 0.25
crit_set = 0
big_sum = 0
sml_sum = 0
big_list = []
sml_list = []
atk_num = 100
atk_num_s = big/sml
tst_num = 1000

for k in range (tst_num):
    big_sum = 0
    #sml_sum = 0
    for i in range (atk_num):
        crit_check = random.random()
        #print(crit_check)
        if crit_check > rate:
            crit_set = 0
        else:
            crit_set = 1
        big_damage = big + big* crit * crit_set
        #print("big damage: ", big_damage)
        big_sum = big_sum + big_damage
    i = i + 1
    #print("big sum: ", big_sum)
    big_average = big_sum/(atk_num)
    #print("big average: ", big_average)
    big_list.append(big_average)
    #print("big list: ", big_list)
   
    sml_sum = 0
    for j in range (atk_num*3):
        crit_check = random.random()
        #print(crit_check)
        if crit_check > rate:
            crit_set = 0
        else:
            crit_set = 1
        sml_damage = sml + sml* crit * crit_set
        #print("small damage: ", sml_damage)
        sml_sum = sml_sum + sml_damage
    j = j + 1
    #print("small sum: ", sml_sum)
    sml_average = sml_sum/(atk_num)
    #print("small average: ", sml_average)
    sml_list.append(sml_average)
    #print("small list: ", sml_list)
#    i = i + 1
#k = k + 1
#print("big sum: ", big_sum)
big_average = big_sum/(atk_num)
#print("big average: ", big_average)
big_list.append(big_average)
#print("big list: ", big_list)
#print("small sum: ", sml_sum)
sml_average = sml_sum/(atk_num)
#print("small average: ", sml_average)
sml_list.append(sml_average)
#print("small list: ", sml_list)
print("Max of big attack logs is ", max(big_list))
print("Max of small attack logs is ", max(sml_list))

---

About 40 less. I expected a smaller difference, but this shows that it pays to do the math.