max_atts = 10000000

attsPerSec = 1.12  # p
hitChance = 0.921  
vilePoisonsRanks = 0

bossResistRate = .83
poisonProcRate = .3 + .02 * vilePoisonsRanks

procChance = hitChance * bossResistRate * poisonProcRate # v
speed = 1/attsPerSec

Q = (1-procChance)**(12*attsPerSec)
P = 1-Q

predictedRate = P * (1-P**5) / Q

print 'Predicted Rate: ', predictedRate

procDur = 12

t = 0.0
atts = 0
stacks = 0
stackTime = 0

procStart = -2 * procDur

from random import random

while atts < max_atts:
    
    if t - procStart > procDur:
        stackTime += 12*stacks
        stacks = 0
    
    roll = random()
    if roll < procChance:
        stackTime += (t-procStart) * stacks
        procStart = t

        stacks += 1
        if stacks > 5:
            stacks = 5
                    
    atts += 1                
    t += speed

if stacks != 0:
    stackTime += stacks * (t-procStart)

print 'Simulated Rate: ', stackTime/t

# Number of attacks in simulation.  More attacks gives more accuracy but takes longer.
max_atts = 10000000

# Set these constants to be consistant with your gear/spec.
attsPerSec = 1.12  # p
hitChance = 0.921  
impPoisonsRanks = 0
masterPoisonerRanks = 0

############################################################
# You should not need to change anything below this line,
# unless you want to alter the fundamental mechanics of this
# program.
############################################################

# Convert talents to actual numbers
bossResistRate = .83 + .05 * masterPoisonerRanks
poisonProcRate = .3 + .02 * impPoisonsRanks

# Compute the chance that poison will be applied on a given attack.
procChance = hitChance * bossResistRate * poisonProcRate # v

# Compute the time between attacks.
speed = 1/attsPerSec

# Compute the theoretical value for both the "periodic attacks" and
# "randomly spaced attacks" situation.  "Randomized" is more appropriate
# to real-world situations; however, the nature of this simulation is 
# such that "periodic" will generally match the simulated results better.
Q = (1-procChance)**(12*attsPerSec)
P = 1-Q

Qprime = (1-procChance)**(int(12*attsPerSec))
Pprime = 1-Qprime

periodicPredictedRate = P * (1-Pprime**5) / Qprime
randomizedPredictedRate = P * (1-P**5) / Q

print 'Predicted Rate (Randomized): ', randomizedPredictedRate
print 'Predicted Rate (Periodic):   ', periodicPredictedRate

# Initialize our bookkeeping variables.
t = 0.0
atts = 0
stacks = 0
stackTime = 0
lastproc = 0

from random import random

# Note that we very much want to use xrange rather than range here
# so as not to try to generate a million-entry list in memory.

for atts in xrange(max_atts):
    # If it has been more than 12 seconds since poison last procced
    # it has ticked off.  Add the number of second-stacks of poison uptime
    # to the total, and reset stacks to zero.
    if t - lastproc > 12:
        stackTime += 12*stacks
        stacks = 0
    
    # Generate a random number to see if poison procs.
    roll = random()
    
    # If poison procs, add the poison uptime in second-stacks to the 
    # total, and update the time of the last proc.
    if roll < procChance:
        stackTime += (t-lastproc) * stacks
        lastproc = t

        stacks += 1
        if stacks > 5:
            stacks = 5

    # Update the time for the next pass through the loop.
    t += speed

# If poison is still ticking at the end, we have not yet counted it's uptime.
# We do so here.
if stacks != 0:
    stackTime += stacks * (t-lastproc)

# Print the simulated poison uptime.
print 'Simulated Rate:              ', stackTime/t

print "DP Modeling, tick-based model"
# Longer times result in better estimates, but take longer to model
maxTime = 100*24*60*60 # 100 days of steady DPS

# Weapon info
speed = 1.5/1.3 # weapon speed (remember to account for SND/Haste)
missChance = (6 + 3.1)/100 # miss + dodge (+ parry)

# Poison talents
impPoisonsRanks = 2
masterPoisonerRanks = 0
vilePoisonsRanks = 3

# Deadly poison rank 7 -> 180 over 12 seconds
dpDamage = 180

############################################################
# You should not need to change anything below this line,
# unless you want to alter the fundamental mechanics of this
# program.
############################################################

# Compute some basic calculated values
attsPerSec = 1/speed # p
hitChance = 1 - missChance
bossResistRate = 0.17 - 0.05 * masterPoisonerRanks
poisonProcRate = 0.3 + 0.02 * impPoisonsRanks

# Compute the chance for DP to proc on any given attack
procChance = hitChance * (1 - bossResistRate) * poisonProcRate # v

# This is Aldriana's prediction equations for uniform/periodic attacks
Q = (1-procChance)**(12*attsPerSec)
P = 1-Q

predictedRate = P * (1-P**5) / Q
print 'Predicted Rate: ', predictedRate

# Define the duration of a DP proc
procDur = 12

# Define variables for tracking our simulation
t = 0.0
stacks = 0
ticks = 0

procStart = -2 * procDur
nextTick = 0.0
nextAtk = speed

from random import random

# Assumption: attack speed is less than 3.0 (valid for all rogue weapons)
while t < maxTime:
    # If the next tick would occur after the duration from the last
    # DP proc has run out, then the stack falls off. Set stacks to 0.
    if procStart + procDur < nextTick:
        stacks = 0 

    # If the next tick is recorded as earlier than the current time,
    # then DP ticked since the last attack occurred. Update our total ticks
    # counter and compute when the next tick will occur.
    if nextTick < t:
        ticks += stacks
        nextTick += 3
    
    # Now, resolve the current attack.
    roll = random()
    if roll < procChance: # Determines if DP procced
        procStart = t
        # This if statement determines type of tick modeling. Comment
        # if you want to assume a global tick. Uncomment if you want to
        # assume ticks are tied to when the first proc lands.
#        if stacks == 0:
#            nextTick = t + 3
        stacks += 1
        if stacks > 5:
            stacks = 5
                
    t += speed

# This section allows the DP stack to tick out at the end
while nextTick < procStart + procDur:
    ticks += stacks
    t = nextTick
    nextTick += 3

# 4 ticks over 12 sec = 1 stack of DP
# 20 ticks over 12 sec = 5 stacks of DP
# Compute average stacks by relating ticks to stacks
print 'Simulated Rate: ', (ticks*3)/t
print 'Simulated DPS:  ', ((ticks*3)/t)*(dpDamage/12)*(1+0.04*vilePoisonsRanks)

print 'End of Simulation'