Gunnery/Arsenal DPS, Simulator, A new approach

[Qed]

After staring intently at Buarl's spreadsheet and Firingrate's sheet, I wanted to try a different approach to theorycrafting DPS and stat weights, simulation! Instead of imposing a model for our rotation and calculating averages, I simulate a single fight for a longass times (~100 days or so goes pretty quickly), using skill-by-skill logic for when to fire each shot.

The result is ... interesting.

First, the code (python, for those who don't recognize it):

Code:

import math
import random

#buffs
smuggler = 1
knight = 1
consular = 1

import sys

#base stats
#aim = 1505
#cun = 140
#tpower = 1213
#power = 345
#crit = 192
#surge = 294
#acc = 147
#alac = 0
#weapondam = 450

aim = 1975 * (1 +.05*consular)
cun = 140 * (1 +.05*consular)
tpower = 1224
power = 502
crit = 187
surge = 238
acc = 198
alac = 77
weapondam = 459

aim    = int(sys.argv[1]) + aim
cun    = int(sys.argv[2]) + cun
tpower = int(sys.argv[3]) + tpower
power  = int(sys.argv[4]) + power
crit   = int(sys.argv[5]) + crit
surge  = int(sys.argv[6]) + surge
acc    = int(sys.argv[7]) + acc
alac   = int(sys.argv[8]) + alac
weapondam = int(sys.argv[9]) + weapondam


#skills
curtain = 1
creact = 1
charger = 1
barrel = 1

#static bonuses
bonus_acc = 0.01
bonus_crit = 0.06 +0.05*smuggler
bonus_alac = 0.04

def diminishing_returns(x,max,lam):
    return max*(1-(1-(0.01/max))**(x/(50*lam)))

#derived stats
armor_dr = 0.8727
nhit = min(.82+bonus_acc+diminishing_returns(acc,0.3,0.55) ,1)
shit = min(.92+bonus_acc+diminishing_returns(acc,0.3,0.55) ,1)
rcrit = 0.05+bonus_crit+diminishing_returns(crit,0.3,0.45)+diminishing_returns(aim,0.3,2​.5)
tcrit = 0.05+bonus_crit+diminishing_returns(crit,0.3,0.45)+diminishing_returns(aim,0.3,2​.5)+diminishing_returns(cun,0.3,2.5)
critvalue = 0.5+diminishing_returns(surge,0.3,0.11)
haste = bonus_alac+diminishing_returns(alac,0.3,0.55)
bonusdmg = (aim*0.2+power*0.23)*(1+0.05*knight)
bonustdmg = (aim*0.2+cun*0.2+power*0.23+tpower*0.23)*(1+0.05*knight)

t = 0
ammo = 12
tot_damage = 0
hi_cd = 0
fa_cd = 0
dr_cd = 0
cof_cd = 0
charger_cd = 0
fa_cof = 0
hi_stacks = 0
creact_cd = 0
recharger_cd = 0
reserve_cd = 0

n_hammer = 0
n_grav = 0
n_hi = 0
n_fa = 0
n_dr = 0

def full_auto():
    global fa_cof
    global ammo
    global passtime
    global fa_cd
    global charger_cd
    global n_fa
    global thisdmg
    global creact_cd
    bdmg = (1610*0.105+weapondam*0.7+bonusdmg*1.05)*(1+fa_cof*0.25)
    passtime = 3*(1-haste-.05*(creact_cd>0))
    if random.uniform(0,1) > shit:
        thisdmg = thisdmg + 0
    elif random.uniform(0,1) < rcrit:
        thisdmg = thisdmg + bdmg*(1+critvalue+0.3)
        creact_cd = 6 + 0.5*(1-haste-.05*(creact_cd>0))
        if charger_cd < 0:
            ammo = ammo+1
            charger_cd = 3 + 0.5*(1-haste-.05*(creact_cd>0))
    else: thisdmg = thisdmg+bdmg
    if random.uniform(0,1) > shit:
        thisdmg = thisdmg + 0
    elif random.uniform(0,1) < rcrit:
        thisdmg = thisdmg + bdmg*(1+critvalue+0.3)
        creact_cd = 6 + 1.5*(1-haste-.05*(creact_cd>0))
        if charger_cd < 0:
            ammo = ammo+1
            charger_cd = 3 + 1.5*(1-haste-.05*(creact_cd>0))
    else: thisdmg = thisdmg+bdmg
    if random.uniform(0,1) > shit:
        thisdmg = thisdmg + 0
    elif random.uniform(0,1) < rcrit:
        thisdmg = thisdmg + bdmg*(1+critvalue+0.3)
        creact_cd = 6 + 2.5*(1-haste-.05*(creact_cd>0))
        if charger_cd < 0:
            ammo = ammo+1
            charger_cd = 3 + 2.5*(1-haste-.05*(creact_cd>0))
    else: thisdmg = thisdmg+bdmg
    fa_cd = 15
    ammo = ammo - 2
    fa_cof = 0
    n_fa = n_fa +1
    #print"Full Auto" , ammo, thisdmg , passtime

def high_impact():
    global thisdmg
    global n_hi
    global hi_stacks
    global hi_cd
    global passtime
    global creact_cd
    bdmg = (1610*0.19+weapondam*1.27+bonusdmg*1.9)*(1+hi_stacks*0.05)
    passtime = 1.5
    if random.uniform(0,1) > shit: thisdmg = 0
    elif random.uniform(0,1) < rcrit:
        thisdmg =  bdmg*(1+critvalue)
        creact_cd = 6
    else: thisdmg = bdmg
    hi_stacks = 0
    hi_cd = 15
    n_hi = n_hi+1
    #print"HI Shot" , ammo, thisdmg , passtime


def demo_round():
    global thisdmg
    global charger_cd
    global ammo
    global dr_cd
    global passtime
    global n_dr
    global creact_cd
    bdmg = (1610*0.2+bonustdmg*2)*1.06*1.25
    passtime = 1.5
    if random.uniform(0,1) < tcrit:
        thisdmg =  bdmg*(1+critvalue+0.3)
        creact_cd = 6
        if charger_cd < 0:
            ammo = ammo+1
            charger_cd = 3
    else: thisdmg = bdmg
    dr_cd = 15
    ammo = ammo - 2
    n_dr = n_dr+1
    #print"Demo Round" , ammo, thisdmg , passtime

def grav_round():
    global thisdmg
    global passtime
    global ammo
    global charger_cd
    global hi_stacks
    global fa_cd
    global cof_cd
    global n_grav
    global creact_cd
    bdmg = (1610*0.21+bonustdmg*2.11)*1.06
    passtime = 1.5*(1-haste-.05*(creact_cd>0))
    if random.uniform(0,1) < (tcrit+.15):
        thisdmg =  bdmg*(1+critvalue)
        creact_cd = 6 + 1.5*(1-haste-.05*(creact_cd>0))
        if charger_cd < 0:
            ammo = ammo+1
            charger_cd = 3
            #print"charger will proc on..."
    else: thisdmg = bdmg
    hi_stacks = min(hi_stacks+1,5)
    if random.uniform(0,1) < 0.3 and cof_cd < 0:
        fa_cof = 1
        #realistically, if is difficult to use full auto immediatly, maybe this should be 1.6?
        fa_cd = 0
        cof_cd = 6
        #print"Curtain of Fire will proc on..."
    ammo = ammo - 2
    n_grav = n_grav+1
    #print"Grav Round" , ammo, thisdmg , passtime

def charged_bolts():
    global thisdmg
    global passtime
    global ammo
    global charger_cd
    global fa_cd
    global cof_cd
    global n_grav
    bdmg = (1610*0.199+weapondam*1.33+bonusdmg*1.99)*1.06
    passtime = 1.5*(1-haste-.05*(creact_cd>0))
    if random.uniform(0,1) > shit:
        thisdmg = 0
    elif random.uniform(0,1) < (tcrit+.15):
        thisdmg =  bdmg*(1+critvalue)
        creact_cd = 6 + 1.5*(1-haste-.05*(creact_cd>0))
        if charger_cd < 0:
            ammo = ammo+1
            charger_cd = 3
            #print"charger will proc on..."
    else: thisdmg = bdmg
    if random.uniform(0,1) < 0.3 and cof_cd < 0:
        fa_cof = 1
        #realistically, if is difficult to use full auto immediatly, maybe this should be 1.6?
        fa_cd = 0
        cof_cd = 6
        #print"Curtain of Fire will proc on..."
    ammo = ammo - 2
    n_grav = n_grav+1
    #print"Charged Bolts" , ammo, thisdmg , passtime

def hammer_shot():
    global thisdmg
    global passtime
    global n_hammer
    thisdmg = 0
    bdmg = weapondam*1+bonusdmg*1*nhit
    passtime = 1.5
    for i in xrange(5):
        if random.uniform(0,1) < rcrit:
            thisdmg =  thisdmg + bdmg*(1+critvalue)/5
            creact_cd = 0.75        
        else: thisdmg = thisdmg + bdmg/5
    n_hammer=n_hammer+1
    #print"Hammer Shot" , ammo, thisdmg , passtime

def cell_recharger():
    global ammo
    global passtime
    global recharger_cd
    ammo=ammo+8
    recharger_cd = 120
    passtime = 0
    #print "!!!CELL RECHARGER!!!" , ammo

def reserve_cell():
    global ammo
    global passtime
    global reserve_cd
    ammo=ammo+2
    reserve_cd = 90
    passtime = 0
    #print "**RESERVE CELL***", ammo


while t < 9999999:
    thisdmg = 0
    passtime = 0
    if recharger_cd <= 0:
        if ammo > 2:
            if dr_cd <= 0 : demo_round()
            else: grav_round()
        else: cell_recharger()
    elif reserve_cd <= 0:
        if ammo > 8:
            if dr_cd <= 0 : demo_round()
            else: grav_round()
        else: reserve_cell()
    else:
        if ammo > 9.2 and fa_cd <= 0: full_auto()
        elif hi_cd <= 0 and ammo < 11: high_impact()
        elif cof_cd > 0:
            if ammo > 11:
                if dr_cd <= 0: demo_round()
                else: grav_round()
            else:
                if ammo > 9.2 and dr_cd <= 0: demo_round()
                else: hammer_shot()
        else:
            if ammo > 9.2:
                if dr_cd <= 0: demo_round()
                else: grav_round()
            else: hammer_shot()
    t = t+passtime
    hi_cd = hi_cd - passtime
    fa_cd = fa_cd - passtime
    dr_cd = dr_cd - passtime
    cof_cd = cof_cd - passtime
    charger_cd = charger_cd - passtime
    recharger_cd = recharger_cd - passtime
    reserve_cd = reserve_cd - passtime
    if ammo+0.6*passtime > 12: print "You suck at ammo managment"
    if ammo > 7.2: ammo = min(ammo+0.6*passtime,12)
    elif ammo > 2.4: ammo = min(ammo+0.36*passtime,12)
    elif ammo > 0: ammo = min(ammo+0.24*passtime,12)
    else:
        ammo = min(ammo+0.36*passtime,12)
        thisdmg = 0
        print "You ran out of ammo, fix your goddamn rotation"
    thisdmg = thisdmg*armor_dr
    tot_damage = tot_damage + thisdmg

    
print "Total Time: ", t , " seconds"
print "Total Damage: " , tot_damage
print "DPS: " , tot_damage/t
print ""
print "Hammer Shots cooldown: " , t/n_hammer
print "Grav Shots cooldown: " , t/n_grav
print "Full Auto cooldown: " , t/n_fa
print "High Impact cooldown: " , t/n_hi
print "Demolition Round cooldown: " , t/n_dr

print "ammo used/sec" , 2*n_grav/t + 2*n_fa/t +2*n_dr/t
#import os
#os.environ['PYTHONINSPECT'] = '1'

(apologies for the massive ugliness)

Because there is some randomness inherent in our rotation, we need a long fight to get a good sample, even though we force each attack to do average damage (though we allow for random crits). As such, it's easier to get stat weights with +10 or +100 rather than +1 of a given stat. At the moment, accuracy is not implemented here, so this will be a measure of the sample-to-sample variation in our dps, rather than a measurement of weight. Lots of of other things aren't implemented either, like the class buffs.

Still, we get 'Effective Power' ratings that are... not insane compared to the more developed approaches:

Code:

baseline
python tsim_cl.py 0 0 0 0 0 0 0 0 0
Total Time:  10000000.0202  seconds
Total Damage:  12992480409.8
DPS:  1299.24803836

+10 power
python tsim_cl.py 0 0 0 10 0 0 0 0 0
Total Time:  10000000.8602  seconds
Total Damage:  13033948721.4
DPS:  1303.39476002

+10 crit
python tsim_cl.py 0 0 0 0 10 0 0 0 0
Total Time:  10000001.8202  seconds
Total Damage:  13029581213.9
DPS:  1302.95788423

+10 surge
python tsim_cl.py 0 0 0 0 0 10 0 0 0
Total Time:  9999999.12019  seconds
Total Damage:  13009019049.4
DPS:  1300.9020194

+10 acc
python tsim_cl.py 0 0 0 0 0 0 10 0 0
Total Time:  10000000.2002  seconds
Total Damage:  12997133416.1
DPS:  1299.71331559

+10 alac
python tsim_cl.py 0 0 0 0 0 0 0 10 0
Total Time:  10000000.2784  seconds
Total Damage:  13014168392.5
DPS:  1301.41680301


baseline
python tsim_cl.py 0 0 0 0 0 0 0 0 0
Total Time:  9999999.54019  seconds
Total Damage:  12996458819.6
DPS:  1299.64594172

+100 power
python tsim_cl.py 0 0 0 100 0 0 0 0 0
Total Time:  9999999.42019  seconds
Total Damage:  13368394567.2
DPS:  1336.83953423

+100 crit
python tsim_cl.py 0 0 0 0 100 0 0 0 0
Total Time:  9999999.66019  seconds
Total Damage:  13316580461.4
DPS:  1331.65809139

+100 surge
python tsim_cl.py 0 0 0 0 0 100 0 0 0
Total Time:  9999999.96019  seconds
Total Damage:  13077954350.6
DPS:  1307.79544026

+100 acc
python tsim_cl.py 0 0 0 0 0 0 100 0 0
Total Time:  10000000.3802  seconds
Total Damage:  12993786346.9
DPS:  1299.37858529

+100 alac
python tsim_cl.py 0 0 0 0 0 0 0 100 0
Total Time:  9999999.9569  seconds
Total Damage:  13153957992.4
DPS:  1315.39580491

Turning this into stat weights:
(Averaged over +10, ~10% statistical uncertainty)

power 1
crit 0.894645499
surge 0.398864736
alac 0.523007047

(Averaged over +100 ~1% statistical uncertainty)
power 1
crit 0.860689907
surge 0.219110282
alac 0.423456357

I'm hoping that this will be useful to crosscheck some of the other DPS calculator methods. At the very least, a simulator allows one, in principal, to test interesting parts of one's approach, like de-prioritizing grav round when Curtain of Fire is on cooldown, or dealing with a situation where one needs to delay Demo Round or HI bolt because all of one's long cooldown abilities are available at the same time.

[bural]

Ohh very nice, we're definitely pushing forward now!
For comparison purposes, is it possible for you to print out characteristics such as damage breakdown, time between TV procs and time between Barrage procs? Also, have you factored in armor somewhere? Can't seem to spot it.
Generally, I find the fairly large percentual dps gap between our 3 models disturbing (lolol pun).

I'd be very interested to hear what you come up with regarding

Quote:to test interesting parts of one's approach, like de-prioritizing grav round when Curtain of Fire is on cooldown

Additionally, it'd be interesting to see how alternating Grav Round and Hammer Shot (to the extent possible under an optimal dps rotation) affects Terminal Velocity proc frequency i.e. how many resources it returns over a given time period.

Finally, how does HSM/Demo Round affect sustained dps in your model if you don't factor in the Heat Signature/Grav Vortex bug?

[Qed]

No armor, no accuracy at the moment. I should rewrite this as something reasonably object oriented before I implement them, or this will get really ugly.

I did do some quick test to see how this priority system affects the 'effective' cooldown of various abilities (ie: how many seconds inbetween full autos, on average), using this rotation. The results are:

Code:

Hammer Shots cooldown:  4.94534625773
Grav Shots cooldown:  4.66504229696
Full Auto cooldown:  12.2970790307
High Impact cooldown:  15.9565735883
Demolition Round cooldown:  16.9606252845

Unsurprisingly, in the real world, we can't quite fire HI and demolition round on cooldown using a strict priority system.

The really ugly thing with this prioity system is situations like this:

Code:

Curtain of Fire will proc on...
Grav Round 8.23408308199 1713.12692011 1.36402776333
Hammer Shot 9.05249973999 830.35 1.5
Hammer Shot 9.95249973999 830.35 1.5
Full Auto 8.85249973999 3312.815625 2.72805552667

Firing grav round procs Curtain of fire, YES!
... and we've dipped under the ammo regen barrier, time to hammer shot back up
... two GCD's later, we can *finally* use the Full Auto that's procced. What a waste.

What I'm writing up presently is a slightly better rotation that saves ammo, except to avoid capping when curtain of fire is on cooldown, in hopes that I can increase the number of full autos I fire.

For the moment, I've just assumed one stack of grav round. I can comment out HSM to see if it's actually worth using.

I'd really like to clean this up so that one can just implement the logic for a rotation priority, without having to copy the math around, something like:

Code:

if ammo <10 and fa_cd < 0:
  fullauto()
elif ammo<10 and dr_cd <0:
  demoround()
else
  hammershot()

That should make it easy to check an 'optimal' rotation.

[bural]

Very very nice!

Quote:Firing grav round procs Curtain of fire, YES!
... and we've dipped under the ammo regen barrier, time to hammer shot back up
... two GCD's later, we can *finally* use the Full Auto that's procced. What a waste.

I take it ammo regen barrier means 7.2 ammo or whereever the interval cuts off for troopers. Surely the priority queue shouldn't prioritize Hammer Shot over FA ever as FA is net generating ammo over it's casttime. I'd imagine accounting for this would bring your effective FA cooldown in same ballpark as mine around 11.2 secs.
If ammo regen barrior = 0 ammo, then forget what I wrote.

[Qed]

Regarding HSM/Demo Round, using 10 day tests:

Simple Priority Rotation:

Code:

python tsim_cl.py 0 0 0 0 0 0 0 0 0
Total Time:  1000000.28859  seconds
Total Damage:  1310777121.01
DPS:  1310.77674273

Hammer Shots cooldown:  4.94178718983
Grav Shots cooldown:  4.65438973329
Full Auto cooldown:  12.3513245382
High Impact cooldown:  15.948204848
Demolition Round cooldown:  16.9534676373

Avoid Grav Shot during CoF Cooldown

Code:

python tsim_cl.py 0 0 0 0 0 0 0 0 0
Total Time:  999999.479642  seconds
Total Damage:  1317815163.57
DPS:  1317.81584931

Hammer Shots cooldown:  5.02292706024
Grav Shots cooldown:  4.73558595634
Full Auto cooldown:  11.8017712065
High Impact cooldown:  16.2667666473
Demolition Round cooldown:  16.6736053296

Avoid Grav Shot during CoF Cooldown, ignore Demo Round while CoF can proc

Code:

python tsim_cl.py 0 0 0 0 0 0 0 0 0
Total Time:  1000000.2273  seconds
Total Damage:  1311871514.9
DPS:  1311.87121672

Hammer Shots cooldown:  5.13980379984
Grav Shots cooldown:  3.96278245636
Full Auto cooldown:  10.8170111231
High Impact cooldown:  16.2382512592
Demolition Round cooldown:  77.4173745681

---

(02-24-2012 10:16 AM)bural Wrote:  I take it ammo regen barrier means 7.2 ammo or whereever the interval cuts off for troopers. Surely the priority queue shouldn't prioritize Hammer Shot over FA ever as FA is net generating ammo over it's casttime. I'd imagine accounting for this would bring your effective FA cooldown in same ballpark as mine around 11.2 secs.
If ammo regen barrior = 0 ammo, then forget what I wrote.

So, the logic here is that you will do hammer shot over full auto if the act of casting full auto would bring you under 7.2 ammo, even if that full auto will regrow some of that ammo during the duration. This makes some sense as, if you're sitting juuust at the ammo breakpoint and you drop down 2 below it, you're not actually going to regen as much during the duration of full-auto since, for some of that duration you'll be in shitty-ammo-regen-land. I think this is exactly what you're saying, rereading the quote.

[Qed]

One last edit, if anyone wants to use this to calculate weights themselves, you can do it with the following additional script:

Code:

import os
os.system("python tsim_cl.py 0 0 0 0 0 0 0 0 0 > baseline.txt")
os.system("python tsim_cl.py 0 0 0 0 0 0 0 0 0 > error.txt")
os.system("python tsim_cl.py 0 0 0 30 0 0 0 0 0 > power.txt")
os.system("python tsim_cl.py 0 0 0 0 30 0 0 0 0 > crit.txt")
os.system("python tsim_cl.py 0 0 0 0 0 30 0 0 0 > surge.txt")
os.system("python tsim_cl.py 0 0 0 0 0 0 30 0 0 > acc.txt")
os.system("python tsim_cl.py 0 0 0 0 0 0 0 30 0 > alac.txt")

dps = {}

for stat in ["baseline","error","power","crit","surge","acc","alac"]:
    file = open(stat+".txt")
    for l in file:
        if l.find("DPS:") > -1:
            words = l.split()
            dps[stat] = float(words[1])
    file.close()

weight = {}

for stat in dps.keys():
    weight[stat] = (dps[stat]-dps["baseline"])/(dps["power"]-dps["baseline"])

for stat in weight.keys():
    print stat , ": " , weight[stat]

two last edits i guess... if we want to compare numbers across spreadsheets, we really need a canonical set of stats to start from. Certainly, I have been using my own personal stats (and then various iterations on them), to test the results, which might be half the explanation for different weights.

[Krix]

I am not going to try to help with the coding here as I am not very good on things like that. But I cant help noticing that according to this simulation the values of power, crit, alacrity and surge fits quite well into the results I got from firingrates. It should lend some value into the fact that surge is not that good.

If you could get accuracy up there we could maybe stop this insane belief in it's superiority once and for all.

[Qed]

(02-24-2012 05:59 PM)Krix Wrote:  I am not going to try to help with the coding here as I am not very good on things like that. But I cant help noticing that according to this simulation the values of power, crit, alacrity and surge fits quite well into the results I got from firingrates. It should lend some value into the fact that surge is not that good.

If you could get accuracy up there we could maybe stop this insane belief in it's superiority once and for all.

Actually, I edited the original post to include hit. What I have is: If you push yourself below the hitcap, the bonus from hit is fairly big. Once you push past the special-attack-hitcap, it's shit though.

With my stats earlier today, but ~95% special attack hit vs bosses:

Code:

acc :  1.13941912858
alac :  0.438220046653
baseline :  0.0
power :  1.0
surge :  0.194956403635
error :  -0.00940488168496
crit :  0.974400136964

Pushing up to 99.5% hit vs bosses (with a delta of 30 to check weights, which pushes well over 100%), with a few other twiddled stats from gear acquisitions tonight (less surge, more crit, less power, more hit):

Code:

acc :  0.0161504745679
alac :  0.531655962903
baseline :  0.0
power :  1.0
surge :  0.352367694068
error :  0.00702216657597
crit :  0.93742024719

[Aldare]

Some very interesting numbers indeed. I'm surprised by how bad Surge is, even after the nerf. What is the crit chance you used for the calculations?

[Krix]

Qed, how have you calculated in accuracy with regards to ranged and technical attacks and normal and special attacks?

if you read my post here: http://sithwarrior.com/forums/Thread-Ars...m?page=27.

How does that post fit into your simulator? I would be happy if someone proved that accuracy works in a different way but for now I am quite confident that is how accuracy works. Providing benefit to only 3 of our single target abilitys in pve.