classic_cat_sim.py

"""Code for simulating the classic WoW feral cat DPS rotation."""

import numpy as np
import copy
import collections
import urllib
import multiprocessing
import psutil


def calc_white_damage(low_end, high_end, miss_chance, crit_chance):
    """Execute single roll table for a melee white attack.

    Arguments:
        low_end (float): Low end base damage of the swing.
        high_end (float): High end base damage of the swing.
        miss_chance (float): Probability that the swing is avoided.
        crit_chance (float): Probability of a critical strike.

    Returns:
        damage_done (float): Damage done by the swing.
        miss (bool): True if the attack was avoided.
        crit (bool): True if the attack was a critical strike.
    """
    outcome_roll = np.random.rand()

    if outcome_roll < miss_chance:
        return 0.0, True, False

    base_dmg = low_end + np.random.rand() * (high_end - low_end)

    if outcome_roll < miss_chance + 0.4:
        glance_reduction = 0.35
        return (1.0 - glance_reduction) * base_dmg, False, False
    if outcome_roll < miss_chance + 0.4 + crit_chance:
        return 2 * base_dmg, False, True
    return base_dmg, False, False


def calc_yellow_damage(low_end, high_end, miss_chance, crit_chance):
    """Execute 2-roll table for a melee spell.

    Arguments:
        low_end (float): Low end base damage of the ability.
        high_end (float): High end base damage of the ability.
        miss_chance (float): Probability that the ability is avoided.
        crit_chance (float): Probability of a critical strike.

    Returns:
        damage_done (float): Damage done by the ability.
        miss (bool): True if the attack was avoided.
        crit (bool): True if the attack was a critical strike.
    """
    miss_roll = np.random.rand()

    if miss_roll < miss_chance:
        return 0.0, True, False

    base_dmg = low_end + np.random.rand() * (high_end - low_end)
    crit_roll = np.random.rand()

    if crit_roll < crit_chance:
        return 2 * base_dmg, False, True
    return base_dmg, False, False


def piecewise_eval(t_fine, times, values):
    """Evaluate a piecewise constant function on a finer time mesh.

    Arguments:
        t_fine (np.ndarray): Desired mesh for evaluation.
        times (np.ndarray): Breakpoints of piecewise function.
        values (np.ndarray): Function values at the breakpoints.

    Returns:
        y_fine (np.ndarray): Function evaluated on the desired mesh.
    """
    result = np.zeros_like(t_fine)

    for i in range(len(times) - 1):
        result += values[i] * ((t_fine >= times[i]) & (t_fine < times[i + 1]))

    result += values[-1] * (t_fine >= times[-1])

    return result


def calc_swing_timer(haste_buffs):
    """Calculate cat swing timer given a list of haste buffs.

    Arguments:
        haste_buffs (list): List of strings denoting the active haste buffs.
            At present, 'mcp', 'icw', 'libram_1', 'libram_2', and 'wcb' are
            supported entries.

    Returns:
        swing_timer (float): Hasted swing timer in seconds.
    """
    haste_multipliers = {
        'mcp': 1.5, 'icw': 1.03, 'libram_1': 1.01, 'libram_2': 1.01,
        'wcb': 1.15
    }

    total_multiplier = 1.0

    for buff in haste_buffs:
        if buff in haste_multipliers:
            total_multiplier *= haste_multipliers[buff]
        else:
            raise ValueError(
                'Unrecognized haste buff "%s". Supported buffs are: %s.' % (
                    buff, haste_multipliers.keys())
            )

    return 1.0 / total_multiplier


def gen_import_link(stat_weights, EP_name='Simmed Weights', multiplier=1.1):
    """Generate 60upgrades stat weight import link from calculated weights.

    Arguments:
        stat_weights (dict): Dictionary of weights generated by a Simulation
            object. Required keys are: "1% hit", "1% crit", and "1% haste".
        EP_name (str): Name for the EP set for auto-populating the 60upgrades
            import interface. Defaults to "Simmed Weights".
        multiplier (float): Scaling factor for raw primary stats. Defaults to
            1.1 assuming Blessing of Kings.

    Returns:
        import_link (str): Full URL for stat weight import into 60upgrades.
    """
    link = 'https://sixtyupgrades.com/ep/import?name='

    # EP Name
    link += urllib.parse.quote(EP_name)

    # Attack Power and Strength
    link += '&31=1&33=1&4=%.2f' % (2.4 * multiplier)

    # Agility
    agi_weight = multiplier * (1 + stat_weights['1% crit'] / 20)
    link += '&0=%.2f' % agi_weight

    # Hit Chance
    link += '&34=%.2f' % stat_weights['1% hit']

    # Critical Strike Chance
    link += '&40=%.2f' % stat_weights['1% crit']

    # Haste
    link += '&42=%.2f' % stat_weights['1% haste']

    return link


class Player():

    """Stores damage parameters, energy, combo points, and cooldowns for a
    simulated player in a boss encounter. Executes events in the cat DPS
    rotation."""

    @property
    def hit_chance(self):
        return self._hit_chance

    @hit_chance.setter
    def hit_chance(self, value):
        self._hit_chance = value
        self.calc_miss_chance()

    def __init__(
            self, attack_power, hit_chance, crit_chance, swing_timer, mana,
            intellect, spirit, mp5, jow=False, pot=True, rune=True,
            bonus_damage=0, shred_bonus=0, bite_rank=4, multiplier=1.1,
            omen=True, feral_aggression=0, blood_frenzy=2, savage_fury=2,
            natural_shapeshifter=3, weapon_speed=2.0, proc_trinkets=[],
            t0_bonus=False, log=False
    ):
        """Initialize player with key damage parameters.

        Arguments:
            attack_power (int): Fully raid buffed attack power.
            hit_chance (float): Chance to hit as a fraction.
            crit_chance (float): Fully raid buffed crit chance as a fraction.
            swing_timer (float): Melee swing timer in seconds, including haste
                effects such as MCP, Warchief's Blessing, and libram enchants.
            mana (int): Fully raid buffed mana.
            intellect (int): Fully raid buffed Intellect.
            spirit (int): Fully raid buffed Spirit.
            mp5 (int): Bonus mp5 from gear or buffs.
            jow (bool): Whether the player is receiving Judgment of Wisdom
                procs. Defaults False.
            pot (bool): Whether mana potions are used. Defaults True.
            rune (bool): Whether Dark/Demonic Runes are used. Defaults True.
            bonus_damage (int): Bonus weapon damage from buffs such as Bogling
                Root or Dense Weightstone. Defaults to 0.
            shred_bonus (int): Bonus damage to Shred ability from Idols and set
                bonuses. Defaults to 0.
            bite_rank (int): Rank of Ferocious Bite to use. Defaults to Rank 4
                for Classic Phase 1-5, but Rank 5 can be specified instead for
                Phase 6.
            multiplier (float): Overall damage multiplier from talents and
                buffs. Defaults to 1.1 (from 5/5 Natural Weapons).
            omen (bool): Whether Omen of Clarity is active. Defaults True.
            feral_aggression (int): Points taken in Feral Aggression talent.
                Defaults to 2.
            blood_frenzy (int): Points taken in Blood Frenzy talent. Defaults
                to 2.
            savage_fury (int): Points taken in Savage Fury talent. Defaults
                to 2.
            natural_shapeshifter (int): Points taken in Natural Shapeshifter
                talent. Defaults to 3.
            weapon_speed (float): Equipped weapon speed, used for calculating
                Omen of Clarity proc rate. Defaults to 2.0.
            proc_trinkets (list of trinkets.ProcTrinket): If applicable, a list
                of ProcTrinket objects modeling each on-hit or on-crit trinket
                used by the player.
            t0_bonus (bool): Whether the 6-piece Shadowcraft set bonus is used.
                Defaults False.
            log (bool): If True, maintain a log of the most recent event,
                formatted as a list of strings [event, outcome, energy, combo
                points]. Defaults False.
        """
        self.attack_power = attack_power

        # Set internal hit value, and derive total miss chance.
        self.hit_chance = hit_chance

        self.crit_chance = crit_chance - 0.048
        self.armor_pen = 0
        self.swing_timer = swing_timer
        self.mana_pool = mana
        self.intellect = intellect
        self.spirit = spirit
        self.mp5 = mp5
        self.jow = jow
        self.pot = pot
        self.rune = rune
        self.t0_bonus = t0_bonus
        self.bonus_damage = bonus_damage
        self.shred_bonus = shred_bonus
        self.bite_rank = bite_rank
        self.damage_multiplier = multiplier
        self.omen = omen
        self.feral_aggression = feral_aggression
        self.blood_frenzy = blood_frenzy
        self.savage_fury = savage_fury
        self.natural_shapeshifter = natural_shapeshifter
        self.weapon_speed = weapon_speed
        self.omen_rates = {
            'white': 2.0/60,
            'yellow': 2.0/60 * self.weapon_speed
        }
        self.proc_trinkets = proc_trinkets
        self.set_mana_regen()
        self.log = log
        self.reset()

    def calc_miss_chance(self):
        """Update overall miss chance when a change to the player's hit percent
        occurs."""
        miss_reduction = min(self._hit_chance * 100, 9.)
        dodge_reduction = 0.
        self.miss_chance = 0.01 * (
            (9. - miss_reduction) + (6.5 - dodge_reduction)
        )

    def set_mana_regen(self):
        """Calculate and store mana regeneration rates based on specified regen
        stats.
        """
        base_regen = 15 + self.spirit / 5
        bonus_regen = self.mp5 / 5 * 2

        self.regen_rates = {
            'base': base_regen + bonus_regen,
            'five_second_rule': bonus_regen,
            'innervated': 5 * base_regen + bonus_regen
        }
        self.shift_cost = 684 * (1 - 0.1 * self.natural_shapeshifter)
        self.pot_threshold = self.mana_pool - 2250

    def calc_damage_params(
            self, gift_of_arthas, boss_armor, sunder, imp_EA, CoR, faerie_fire,
            annihilator, tigers_fury=False
    ):
        """Calculate high and low end damage of all abilities as a function of
        specified boss debuffs."""
        bonus_damage = (
            self.attack_power/14 + self.bonus_damage + 40 * tigers_fury - 10.1
        )

        # Legacy compatibility with older Sunder code in case it is needed
        if isinstance(sunder, bool):
            sunder *= 5

        residual_armor = max(0, (
            boss_armor - max(sunder * 450, imp_EA * 2550) - 640 * CoR
            - 505 * faerie_fire - 600 * annihilator - self.armor_pen
        ))
        armor_multiplier = 1 - residual_armor / (residual_armor + 400 + 85*60)
        self.multiplier = armor_multiplier * self.damage_multiplier
        self.white_low = (60*0.85 + bonus_damage) * self.multiplier
        self.white_high = (60*1.25 + bonus_damage) * self.multiplier
        self.shred_low = (
            self.white_low * 2.25 + (180 + self.shred_bonus) * self.multiplier
        )
        self.shred_high = (
            self.white_high * 2.25 + (180 + self.shred_bonus) * self.multiplier
        )
        self.bite_multiplier = (
            self.multiplier * (1 + 0.03 * self.feral_aggression)
        )

        # 11/13/21 - Added toggle for both Rank 4 and Rank 5 Bite
        if self.bite_rank == 4:
            self.bite_low = {
                5: (685 + 0.15 * self.attack_power) * self.bite_multiplier,
                4: (557 + 0.12 * self.attack_power) * self.bite_multiplier
            }
            self.bite_high = {
                5: (735 + 0.15 * self.attack_power) * self.bite_multiplier,
                4: (607 + 0.12 * self.attack_power) * self.bite_multiplier
            }
        else:
            self.bite_low = {
                5: (787 + 0.15 * self.attack_power) * self.bite_multiplier,
                4: (640 + 0.12 * self.attack_power) * self.bite_multiplier
            }
            self.bite_high = {
                5: (847 + 0.15 * self.attack_power) * self.bite_multiplier,
                4: (700 + 0.12 * self.attack_power) * self.bite_multiplier
            }

        claw_fac = 1 + 0.1 * self.savage_fury
        self.claw_low = claw_fac * (self.white_low + 115 * self.multiplier)
        self.claw_high = claw_fac * (self.white_high + 115 * self.multiplier)

        # Need to double check that both the scaling coefficients and base
        # damage values are correct! In TBC, we had to change them, and the
        # tooltips were incorrect...
        self.rip_tick = {
            5: (942 + 0.24*self.attack_power) / 6 * self.damage_multiplier,
            4: (774 + 0.24*self.attack_power) / 6 * self.damage_multiplier
        }

        # Adjust damage values for Gift of Arthas
        if not gift_of_arthas:
            return

        for bound in ['low', 'high']:
            for ability in ['white', 'shred', 'claw']:
                attr = '%s_%s' % (ability, bound)
                setattr(self, attr, getattr(self, attr) + 8 * armor_multiplier)

            bite_damage = getattr(self, 'bite_%s' % bound)

            for cp in [4, 5]:
                bite_damage[cp] += 8 * armor_multiplier

    def reset(self):
        """Reset fight-specific parameters to their starting values at the
        beginning of an encounter."""
        self.gcd = 0.0
        self.omen_proc = False
        self.omen_icd = 0.0
        self.energy = 100
        self.combo_points = 0
        self.mana = self.mana_pool
        self.rune_cd = 0.0
        self.pot_cd = 0.0
        self.innervated = False
        self.innervate_cd = 0.0
        self.five_second_rule = False
        self.cat_form = True
        self.t0_proc = False

        # Create dictionary to hold breakdown of total casts and damage
        self.dmg_breakdown = collections.OrderedDict()

        for cast_type in [
            'Melee', 'Shred', 'Rip', 'Claw', 'Ferocious Bite', 'Shift'
        ]:
            self.dmg_breakdown[cast_type] = {'casts': 0, 'damage': 0.0}

    def check_omen_proc(self, yellow=False):
        """Check for Omen of Clarity proc on a successful swing.

        Arguments:
            yellow (bool): Check proc for a yellow ability rather than a melee
                swing. Defaults False.
        """
        if not self.omen:
            return
        if self.omen_icd > 1e-9:
            return

        if yellow:
            proc_rate = self.omen_rates['yellow']
        else:
            proc_rate = self.omen_rates['white']

        proc_roll = np.random.rand()

        if proc_roll < proc_rate:
            self.omen_proc = True
            self.omen_icd = 10.0

    def check_jow_proc(self):
        """Check for a Judgment Wisdom on a successful melee attack."""
        if not self.jow:
            return

        proc_roll = np.random.rand()

        if proc_roll < 0.5:
            self.mana = min(self.mana + 59, self.mana_pool)

    def check_t0_proc(self, yellow=False):
        """Check for a 6p-Shadowcraft energy proc on a successful melee
        attack.

        Arguments:
            yellow (bool): Check proc for a yellow ability rather than a melee
                swing. Defaults False.
        """
        self.t0_proc = False

        if yellow or (not self.t0_bonus):
            return

        proc_roll = np.random.rand()

        if proc_roll < 1/60.:
            self.energy = min(self.energy + 35, 100)
            self.t0_proc = True

    def check_procs(self, yellow=False, crit=False):
        """Check all relevant procs that trigger on a successful attack.

        Arguments:
            yellow (bool): Check proc for a yellow ability rather than a melee
                swing. Defaults False.
            crit (bool): Whether the attack was a critical strike. Defaults
                False.
        """
        self.check_omen_proc(yellow=yellow)
        self.check_jow_proc()
        self.check_t0_proc(yellow=yellow)

        for trinket in self.proc_trinkets:
            trinket.check_for_proc(crit, yellow)

    def regen_mana(self):
        """Update player mana on a Spirit tick."""
        if self.innervated:
            regen = self.regen_rates['innervated']
        elif self.five_second_rule:
            regen = self.regen_rates['five_second_rule']
        else:
            regen = self.regen_rates['base']

        self.mana = min(self.mana + regen, self.mana_pool)

    def use_rune(self):
        """Pop a Dark/Demonic Rune to restore mana when appropriate.

        Returns:
            rune_used (bool): Whether the rune was used.
        """
        if ((not self.rune) or (self.rune_cd > 1e-9)
                or (self.mana > self.mana_pool - 1500)):
            return False

        self.mana += (900 + np.random.rand() * 600)
        self.rune_cd = 120.0
        return True

    def use_pot(self):
        """Pop a Mana Potion to restore mana when appropriate.

        Returns:
            pot_used (bool): Wheter the potion was used.
        """
        if ((not self.pot) or (self.pot_cd > 1e-9)
                or (self.mana > self.pot_threshold)):
            return False

        self.pot_cd = 120.0
        self.mana += (1350 + np.random.rand() * 900)
        return True

    def swing(self):
        """Execute a melee swing.

        Returns:
            damage_done (float): Damage done by the swing.
        """
        damage_done, miss, crit = calc_white_damage(
            self.white_low, self.white_high, self.miss_chance, self.crit_chance
        )

        # Check for Omen and JoW procs
        if not miss:
            self.check_procs(crit=crit)

        # Log the swing
        self.dmg_breakdown['Melee']['casts'] += 1
        self.dmg_breakdown['Melee']['damage'] += damage_done

        if self.log:
            self.gen_log('melee', damage_done, miss, crit, False)

        return damage_done

    def gen_log(self, ability_name, dmg_done, miss, crit, clearcast):
        """Generate a combat log entry for an ability.

        Arguments:
            ability_name (str): Name of the ability.
            dmg_done (float): Damage done by the ability.
            miss (bool): Whether the ability missed.
            crit (bool): Whether the ability crit.
            clearcast (bool): Whether the ability was a Clearcast.
        """
        if miss:
            damage_str = 'miss' + ' (clearcast)' * clearcast
        else:
            try:
                damage_str = '%d' % dmg_done
            except TypeError:
                damage_str = dmg_done

            if crit and clearcast:
                damage_str += ' (crit, clearcast)'
            elif crit:
                damage_str += ' (crit)'
            elif clearcast:
                damage_str += ' (clearcast)'

            if self.t0_proc:
                if ')' in damage_str:
                    damage_str = damage_str[:-1] + ', T0 proc)'
                else:
                    damage_str += ' (T0 proc)'

        self.combat_log = [
            ability_name, damage_str, '%d' % self.energy,
            '%d' % self.combo_points, '%d' % self.mana
        ]

    def execute_builder(self, ability_name, min_dmg, max_dmg, energy_cost):
        """Execute a combo point builder (either Claw, Shred, or Mangle).

        Arguments:
            ability_name (str): Name of the ability for use in logging.
            min_dmg (float): Low end damage of the ability.
            max_dmg (float): High end damage of the ability.
            energy_cost (int): Energy cost of the ability.

        Returns:
            damage_done (float): Damage done by the ability.
        """
        # Perform Monte Carlo
        damage_done, miss, crit = calc_yellow_damage(
            min_dmg, max_dmg, self.miss_chance, self.crit_chance
        )

        # Set GCD
        self.gcd = 1.0

        # Update energy
        clearcast = self.omen_proc

        if clearcast:
            self.omen_proc = False
        else:
            self.energy -= energy_cost * (1 - 0.8 * miss)

        # Update combo points
        points_added = 1 * (not miss)

        if crit and (self.blood_frenzy > 0):
            if self.blood_frenzy == 1:
                bf_roll = np.random.rand()
                points_added += (bf_roll < 0.5)
            else:
                points_added += 1

        self.combo_points = min(5, self.combo_points + points_added)

        # Check for Omen and JoW procs
        if not miss:
            self.check_procs(yellow=True, crit=crit)

        # Log the cast
        self.dmg_breakdown[ability_name]['casts'] += 1
        self.dmg_breakdown[ability_name]['damage'] += damage_done

        if self.log:
            self.gen_log(ability_name, damage_done, miss, crit, clearcast)

        return damage_done

    def shred(self):
        """Execute a Shred.

        Returns:
            damage_done (float): Damage done by the Shred cast.
        """
        return self.execute_builder(
            'Shred', self.shred_low, self.shred_high, 48
        )

    def claw(self):
        """Execute a Claw.

        Returns:
            damage_done (float): Damage done by the Claw cast.
        """
        return self.execute_builder('Claw', self.claw_low, self.claw_high, 40)

    def bite(self):
        """Execute a Ferocious Bite.

        Returns:
            damage_done (float): Damage done by the Bite cast.
        """
        # Bite always costs at least 35 combo points without Omen of Clarity
        clearcast = self.omen_proc

        if clearcast:
            self.omen_proc = False
        else:
            self.energy -= 35

        # Update Bite damage based on excess energy available
        bonus_damage = self.energy * 2.7 * self.bite_multiplier

        # Perform Monte Carlo
        damage_done, miss, crit = calc_yellow_damage(
            self.bite_low[self.combo_points] + bonus_damage,
            self.bite_high[self.combo_points] + bonus_damage, self.miss_chance,
            self.crit_chance
        )

        # Consume energy pool and combo points on successful Bite
        self.energy *= miss
        self.combo_points *= miss

        # Set GCD
        self.gcd = 1.0

        # Check for Omen and JoW procs
        if not miss:
            self.check_procs(yellow=True, crit=crit)

        # Log the cast
        self.dmg_breakdown['Ferocious Bite']['casts'] += 1
        self.dmg_breakdown['Ferocious Bite']['damage'] += damage_done

        if self.log:
            self.gen_log('Ferocious Bite', damage_done, miss, crit, clearcast)

        return damage_done

    def rip(self):
        """Cast Rip as a finishing move.

        Returns:
            damage_per_tick (float): Damage done per subsequent Rip tick.
            success (bool): Whether the Rip debuff was successfully applied.
        """
        # Perform Monte Carlo to see if it landed and record damage per tick
        miss = (np.random.rand() < self.miss_chance)
        damage_per_tick = self.rip_tick[self.combo_points] * (not miss)

        # Set GCD
        self.gcd = 1.0

        # Update energy
        clearcast = self.omen_proc

        if clearcast:
            self.omen_proc = False
        else:
            self.energy -= 30

        # Consume combo points on successful cast
        self.combo_points *= miss

        # Check for Omen and JoW procs
        if not miss:
            self.check_procs(yellow=True)

        # Log the cast and total damage that will be done
        self.dmg_breakdown['Rip']['casts'] += 1
        self.dmg_breakdown['Rip']['damage'] += damage_per_tick * 6

        if self.log:
            self.gen_log('Rip', 'applied', miss, False, clearcast)

        return damage_per_tick, not miss

    def shift(self, time):
        """Execute a powershift.

        Arguments:
            time (float): Time at which the shift is executed, in seconds. Used
                for determining the five second rule.
        """
        self.energy = 60
        self.gcd = 1.5
        self.dmg_breakdown['Shift']['casts'] += 1
        self.mana -= self.shift_cost
        self.five_second_rule = True
        self.last_cast_time = time
        self.cat_form = True
        mana_str = ''

        # Pop a Dark Rune if we can get full value from it
        if self.use_rune():
            mana_str = 'use Dark Rune'

        # Pop a Mana Potion if we can get full value from it
        if self.use_pot():
            mana_str = 'use Mana Potion'

        if self.log:
            self.combat_log = [
                'shift', mana_str, '%d' % self.energy,
                '%d' % self.combo_points, '%d' % self.mana
            ]

    def innervate(self, time):
        """Cast Innervate.

        Arguments:
            time (float): Time of Innervate cast, in seconds. Used for
                determining when the Innervate buff falls off.
        """
        self.mana -= 62  # Innervate mana cost
        self.innervate_end = time + 20
        self.innervated = True
        self.cat_form = False
        self.energy = 0
        self.gcd = 1.5
        self.innervate_cd = 360.0

        if self.log:
            self.combat_log = [
                'Innervate', '', '%d' % self.energy,
                '%d' % self.combo_points, '%d' % self.mana
            ]


class ArmorDebuffs():

    """Controls the delayed application of boss armor debuffs after an
    encounter begins. At present, only Sunder Armor and Expose Armor are
    modeled with delayed application, and all other boss debuffs are modeled
    as applying instantly at the fight start."""

    def __init__(self, sim):
        """Initialize controller by specifying whether Sunder, EA, or both will
        be applied.

        sim (Simulation): Simulation object controlling fight execution. The
            params dictionary of the Simulation will be modified by the debuff
            controller during the fight.
        """
        self.params = sim.params
        self.process_params()

    def process_params(self):
        """Use the simulation's existing params dictionary to determine whether
        Sunder, EA, or both should be applied."""
        self.use_sunder = bool(self.params['sunder'])
        self.use_ea = bool(self.params['imp_EA'])
        self.reset()

    def reset(self):
        """Remove all armor debuffs at the start of a fight."""
        self.params['sunder'] = 0
        self.params['imp_EA'] = False

    def update(self, time, player, sim):
        """Add Sunder or EA applications at the appropriate times. Currently,
        the debuff schedule is hard coded as 1 Sunder stack every GCD, and
        EA applied at 15 seconds if used. This can be made more flexible if
        desired in the future using class attributes.

        Arguments:
            time (float): Simulation time, in seconds.
            player (tbc_cat_sim.Player): Player object whose attributes will be
                modified by the trinket proc.
            sim (tbc_cat_sim.Simulation): Simulation object controlling the
                fight execution.
        """
        # If we are Sundering and are at less than 5 stacks, then add a stack
        # every GCD.
        if (self.use_sunder and (self.params['sunder'] < 5)
                and (time >= 1.5 * self.params['sunder'])):
            self.params['sunder'] += 1

            if sim.log:
                sim.combat_log.append(
                    sim.gen_log(time, 'Sunder Armor', 'applied')
                )

            player.calc_damage_params(**self.params)
        elif self.use_ea and (not self.params['imp_EA']) and (time >= 15.):
            self.params['imp_EA'] = True

            if sim.log:
                if self.params['sunder'] > 0:
                    sim.combat_log.append(
                        sim.gen_log(time, 'Sunder Armor', 'falls off')
                    )

                sim.combat_log.append(
                    sim.gen_log(time, 'Expose Armor', 'applied')
                )

            player.calc_damage_params(**self.params)

        return 0.0


class Simulation():

    """Sets up and runs a simulated fight with the cat DPS rotation."""

    # Default fight parameters, including boss armor and all relevant debuffs.
    default_params = {
        'gift_of_arthas': True,
        'boss_armor': 3731,
        'sunder': True,
        'imp_EA': True,
        'CoR': True,
        'faerie_fire': True,
        'annihilator': False,
    }

    # Default parameters specifying the player execution strategy
    default_strategy = {
        'prepop_TF': False,
        'prepop_numticks': 2,
        'min_combos_for_rip': 6,
        'use_claw_trick': True,
        'use_bite': True,
        'bite_time': 0.0,
        'min_combos_for_bite': 5,
        'use_innervate': True,
        'max_wait_time': 1.0,
    }

    def __init__(
        self, player, fight_length, num_mcp=0, trinkets=[], **kwargs
    ):
        """Initialize simulation.

        Arguments:
            player (Player): An instantiated Player object which can execute
                the DPS rotation.
            fight_length (float): Fight length in seconds.
            num_mcp (int): Maximum number of MCPs that can be used during the
                fight. If nonzero, the Player object should be instantiated
                with a hasted swing timer, and the simulation will slow it down
                once the haste buff expires. Defaults to 0.
            trinkets (list of trinkets.Trinket): List of ActivatedTrinket or
                ProcTrinket objects that will be used on cooldown.
            kwargs (dict): Key, value pairs for all other encounter parameters,
                including boss armor, relevant debuffs, and player stregy
                specification. An error will be thrown if the parameter is not
                recognized. Any parameters not supplied will be set to default
                values.
        """
        self.player = player
        self.fight_length = fight_length
        self.max_mcp = int(round(num_mcp))
        self.trinkets = trinkets
        self.params = copy.deepcopy(self.default_params)
        self.strategy = copy.deepcopy(self.default_strategy)

        for key, value in kwargs.items():
            if key in self.params:
                self.params[key] = value
            elif key in self.strategy:
                self.strategy[key] = value
            else:
                raise KeyError(
                    ('"%s" is not a supported parameter. Supported encounter '
                     'parameters are: %s. Supported strategy parameters are: '
                     '%s.') % (key, self.params.keys(), self.strategy.keys())
                )

        # Determine whether Ferocious Bite is to be used instead of Rip as the
        # primary finishing move.
        self.strategy['bite_over_rip'] = (
            self.strategy['use_bite']
            and (self.strategy['min_combos_for_rip'] > 5)
        )
        self.strategy['no_finisher'] = (
            (not self.strategy['use_bite'])
            and (self.strategy['min_combos_for_rip'] > 5)
        )

        # Set up controller for delayed armor debuffs. The controller can be
        # treated identically to a Trinket object as far as the sim is
        # concerned.
        self.debuff_controller = ArmorDebuffs(self)
        self.trinkets.append(self.debuff_controller)

        # Calculate damage ranges for player abilities under the given
        # encounter parameters.
        self.player.calc_damage_params(**self.params)

    def set_active_debuffs(self, debuff_list):
        """Set active debuffs according to a specified list.

        Arguments:
            debuff_list (list): List of strings containing supported debuff
                names.
        """
        active_debuffs = copy.copy(debuff_list)
        all_debuffs = [key for key in self.params if key != 'boss_armor']

        for key in all_debuffs:
            if key in active_debuffs:
                self.params[key] = True
                active_debuffs.remove(key)
            else:
                self.params[key] = False

        if active_debuffs:
            raise ValueError(
                'Unsupported debuffs found: %s. Supported debuffs are: %s.' % (
                    active_debuffs, self.params.keys()
                )
            )

        self.debuff_controller.process_params()

    def gen_log(self, time, event, outcome):
        """Generate a custom combat log entry.

        Arguments:
            time (float): Current simulation time in seconds.
            event (str): First "event" field for the log entry.
            outcome (str): Second "outcome" field for the log entry.
        """
        return [
            '%.3f' % time, event, outcome, '%d' % self.player.energy,
            '%d' % self.player.combo_points, '%d' % self.player.mana
        ]

    def innervate_or_shift(self, time):
        """Decide whether to cast Innervate or perform a normal powershift.

        Arguments:
            time (float): Current simulation time in seconds.
        """
        # Only Innervate if (a) we don't have enough mana for two shifts, (b)
        # the fight isn't ending, and (c) Innervate is not on cooldown.
        if (self.strategy['use_innervate']
                and (self.player.mana <= self.innervate_threshold)
                and (time < self.fight_length - 1.6)
                and (self.player.innervate_cd < 1e-9)):
            # First execute the Innervate cast. Player object will track the
            # time of cast.
            self.player.innervate(time)

            # Next we need to reset the melee swing timer since we're staying
            # in caster form. We'll use the same logic as at the start of
            # combat, setting the first swing just slightly after the shift
            # back into cat.
            self.update_swing_times(
                time + 1.5 + 0.1 * np.random.rand(), self.swing_timer,
                first_swing=True
            )
        else:
            self.player.shift(time)

        # If needed, squeeze in a weapon swap into the same GCD
        if (not self.mcp_equipped) and (self.num_mcp >= 1):
            self.mcp_equipped = True
            self.mcp_cd = 30.0
            self.num_mcp -= 1

    def rip(self, time):
        """Instruct Player to apply Rip, and perform related bookkeeping.

        Arguments:
            time (float): Current simulation time in seconds.
        """
        damage_per_tick, success = self.player.rip()

        if success:
            self.rip_debuff = True
            self.rip_end = time + 12.0
            self.rip_ticks = list(np.arange(time + 2, time + 12.01, 2))
            self.rip_damage = damage_per_tick

    def execute_rotation(self, time, next_tick):
        """Execute the next player action in the DPS rotation according to the
        specified player strategy in the simulation.

        Arguments:
            time (float): Current simulation time in seconds.
            next_tick (float): Time of next energy tick, in seconds.

        Returns:
            damage_done (float): Damage done by the player action.
        """
        # If we're out of form because we just cast Innervate, always shift
        if not self.player.cat_form:
            self.player.shift(time)
            return 0.0

        energy, cp = self.player.energy, self.player.combo_points
        rip_cp = self.strategy['min_combos_for_rip']
        bite_cp = self.strategy['min_combos_for_bite']

        # 10/6/21 - Added logic to not cast Rip if we're near the end of the
        # fight.
        end_thresh = 10
        rip_now = (cp >= rip_cp) and (not self.rip_debuff)
        rip_now = rip_now and (self.fight_length - time >= end_thresh)
        bite_at_end = ((cp >= bite_cp) and (
            (self.fight_length - time < end_thresh)
            or (self.rip_debuff and (
                self.fight_length - self.rip_end < end_thresh))
        ) and (not self.strategy['no_finisher'])
        )

        bite_before_rip = (
            self.rip_debuff and self.strategy['use_bite']
            and (self.rip_end - time >= self.strategy['bite_time'])
        )
        bite_now = (
            (bite_before_rip or self.strategy['bite_over_rip'])
            and (cp >= bite_cp)
        )
        rip_next = (
            (rip_now or ((cp >= rip_cp) and (self.rip_end <= next_tick)))
            and (self.fight_length - next_tick >= end_thresh)
        )
        bite_before_rip_next = (
            bite_before_rip
            and (self.rip_end - next_tick >= self.strategy['bite_time'])
        )
        time_to_next_tick = next_tick - time

        if self.player.mana < self.player.shift_cost:
            # If this is the first time we're oom, log it
            if self.time_to_oom is None:
                self.time_to_oom = time

            # No-shift rotation
            if (rip_now and ((energy >= 30) or self.player.omen_proc)):
                self.rip(time)
            elif energy >= 63:
                return self.player.shred()
            elif (bite_now and ((energy >= 35) or self.player.omen_proc)):
                return self.player.bite()
            elif (energy >= 48) or self.player.omen_proc:
                return self.player.shred()
        elif energy < 10:
            self.innervate_or_shift(time)
        elif rip_now:
            if (energy >= 30) or self.player.omen_proc:
                self.rip(time)
            elif time_to_next_tick > self.strategy['max_wait_time']:
                self.innervate_or_shift(time)
        elif (bite_now or bite_at_end):
            # Decision tree for Bite usage is more complicated, so there is
            # some duplicated logic with the main tree.

            # Shred versus Bite decision is the same as vanilla criteria
            if (energy >= 63) or ((energy >= 15) and self.player.omen_proc):
                return self.player.shred()
            if energy >= 35:
                return self.player.bite()

            # If we are doing the Rip rotation with Bite filler, then there is
            # a case where we would Bite now if we had enough energy, but once
            # we gain enough energy to do so, it's too late to Bite relative to
            # Rip falling off. In this case, we wait for the tick only if we
            # can Shred afterward, and otherwise shift and won't Bite
            # at all this cycle. Returning 0.0 is the same thing as waiting for
            # the next tick, so this logic could be written differently if
            # desired to match the rest of the rotation code, where waiting for
            # tick is handled implicitly instead.
            if ((energy >= 28) and bite_before_rip
                    and (not bite_before_rip_next)):
                wait = True
            elif ((energy >= 15) and
                    ((not bite_before_rip)
                     or bite_before_rip_next or bite_at_end)):
                wait = True
            elif (not rip_next):
                wait = False
                self.innervate_or_shift(time)
            else:
                wait = True

            if wait and (time_to_next_tick > self.strategy['max_wait_time']):
                self.innervate_or_shift(time)
        elif energy >= 28:
            if (energy >= 48) or self.player.omen_proc:
                return self.player.shred()
            if ((energy >= 40) and (time_to_next_tick > 1.0)
                    and self.strategy['use_claw_trick']):
                return self.player.claw()
            if time_to_next_tick > self.strategy['max_wait_time']:
                self.innervate_or_shift(time)
        elif (not rip_next):
            self.innervate_or_shift(time)
        elif time_to_next_tick > self.strategy['max_wait_time']:
            self.innervate_or_shift(time)

        return 0.0

    def update_swing_times(self, time, new_swing_timer, first_swing=False):
        """Generate an updated list of swing times after changes to the swing
        timer have occurred.

        Arguments:
            time (float): Simulation time at which swing timer is changing, in
                seconds.
            new_swing_timer (float): Updated swing timer.
            first_swing (bool): If True, generate a fresh set of swing times
                at the start of a simulation. Defaults False.
        """
        # First calculate the start time for the next swing.
        if first_swing:
            start_time = time
        else:
            frac_remaining = (self.swing_times[0] - time) / self.swing_timer
            start_time = time + frac_remaining * new_swing_timer

        # Now update the internal swing times
        self.swing_timer = new_swing_timer

        if start_time > self.fight_length - self.swing_timer:
            self.swing_times = [
                start_time, start_time + self.swing_timer
            ]
        else:
            self.swing_times = list(np.arange(
                start_time, self.fight_length + self.swing_timer,
                self.swing_timer
            ))

    def drop_tigers_fury(self, time):
        """Remove Tiger's Fury buff and document if requested.

        Arguments:
            time (float): Simulation time when Tiger's Fury fell off, in
                seconds. Used only for logging.
        """
        self.params['tigers_fury'] = False
        self.player.calc_damage_params(**self.params)

        if self.log:
            self.combat_log.append(
                self.gen_log(time, "Tiger's Fury", 'falls off')
            )

    def run(self, log=False):
        """Run a simulated trajectory for the fight.

        Arguments:
            log (bool): If True, generate a full combat log of events within
                the simulation. Defaults False.

        Returns:
            times, damage, energy, combos: Lists of the time,
                total damage done, player energy, and player combo points at
                each simulated event within the fight duration.
            damage_breakdown (collection.OrderedDict): Dictionary containing a
                breakdown of the number of casts and damage done by each player
                ability.
            aura_stats (list of lists): Breakdown of the number of activations
                and total uptime of each buff aura applied from trinkets and
                other cooldowns.
            combat_log (list of lists): Each entry is a list [time, event,
                outcome, energy, combo points, mana] all formatted as strings.
                Only output if log == True.
        """
        # Reset player to fresh fight
        self.player.reset()
        self.innervate_threshold = 2 * self.player.shift_cost + 62
        self.rip_debuff = False

        # Configure combat logging if requested
        self.log = log

        if self.log:
            self.player.log = True
            self.combat_log = []
        else:
            self.player.log = False

        # Fight begins at a random time relative to energy tick. Since we start
        # at 100 energy, let's random roll the time of the next tick.
        energy_tick_start = 2.0 * np.random.rand()

        # Create array of energy tick times
        energy_tick_times = list(np.arange(
            energy_tick_start, self.fight_length + 2, 2
        ))

        # Same thing for swing times, except that the first swing will occur at
        # most 100 ms after the first special just to simulate some latency and
        # avoid errors from Omen procs on the first swing.
        swing_timer_start = 0.1 * np.random.rand()
        self.update_swing_times(
            swing_timer_start, self.player.swing_timer, first_swing=True
        )

        # Adjust damage calculation if Tiger's Fury is pre-popped, and
        # calculate when it should fall off for the specified strategy. Assume
        # TF is popped 100 ms before the appropriate energy tick.
        if self.strategy['prepop_TF']:
            tf_end = (
                energy_tick_start - 0.1 + 6
                - 2 * self.strategy['prepop_numticks']
            )
            self.player.energy -= 10 * (2 - self.strategy['prepop_numticks'])
            self.params['tigers_fury'] = True
            self.player.calc_damage_params(**self.params)
        else:
            self.params['tigers_fury'] = False

        # Determine whether MCP will be used, and activate it if so
        self.num_mcp = self.max_mcp

        if self.num_mcp >= 1:
            self.mcp_equipped = True
            mcp_active = True
            mcp_end = 90.0
            self.num_mcp -= 1
            self.mcp_cd = 0.0
            self.proc_end_times = [mcp_end]
        else:
            self.mcp_equipped = False
            self.proc_end_times = []

        # Reset all trinkets to fresh state
        for trinket in self.trinkets:
            trinket.reset()

        # Create placeholder for time to OOM if the player goes OOM in the run
        self.time_to_oom = None

        # Create empty lists of output variables
        times = []
        damage = []
        energy = []
        combos = []

        # The "damage_done" for Rip that is logged by the Player object is not
        # accurate to a given run, as it does not incorporate partial Rip ticks
        # at the end. So we'll keep track of it ourselves.
        rip_damage = 0.0

        # Run simulation
        time = 0.0
        previous_time = 0.0

        while time <= self.fight_length:
            # Tabulate all damage sources in this timestep
            dmg_done = 0.0

            # Decrement cooldowns by time since last event
            delta_t = time - previous_time
            self.player.gcd = max(0.0, self.player.gcd - delta_t)
            self.player.omen_icd = max(0.0, self.player.omen_icd - delta_t)
            self.player.rune_cd = max(0.0, self.player.rune_cd - delta_t)
            self.player.pot_cd = max(0.0, self.player.pot_cd - delta_t)
            self.player.innervate_cd = max(
                0.0, self.player.innervate_cd - delta_t
            )

            if self.mcp_equipped:
                self.mcp_cd = max(0.0, self.mcp_cd - delta_t)

            if (self.player.five_second_rule
                    and (time - self.player.last_cast_time >= 5)):
                self.player.five_second_rule = False

            # Check if Innervate fell off
            if self.player.innervated and (time >= self.player.innervate_end):
                self.player.innervated = False

                if self.log:
                    self.combat_log.append(self.gen_log(
                        self.player.innervate_end, 'Innervate', 'falls off'
                    ))

            # Check if Tiger's Fury fell off
            if self.params['tigers_fury'] and (time >= tf_end):
                self.drop_tigers_fury(tf_end)

            # Check if haste buff is expired or if a new one can be popped
            if self.mcp_equipped and mcp_active and (time > mcp_end - 1e-9):
                mcp_active = False
                self.mcp_equipped = False
                self.update_swing_times(time, self.swing_timer * 1.5)

                if self.log:
                    self.combat_log.append(self.gen_log(
                        mcp_end, 'Haste', 'falls off'
                    ))
            elif self.mcp_equipped and (not mcp_active) and (self.mcp_cd == 0):
                mcp_active = True
                self.update_swing_times(time, self.swing_timer / 1.5)
                mcp_end = time + 90.0
                self.proc_end_times.append(mcp_end)

                if self.log:
                    self.combat_log.append(
                        self.gen_log(time, 'Haste', 'applied')
                    )

            # Check if a Rip tick happens at this time
            if self.rip_debuff and (time == self.rip_ticks[0]):
                tick_damage = self.rip_damage
                dmg_done += tick_damage
                rip_damage += tick_damage
                self.rip_ticks.pop(0)

                if self.log:
                    self.combat_log.append(
                        self.gen_log(time, 'Rip tick', '%d' % tick_damage)
                    )

            # Check if Rip fell off
            if self.rip_debuff and (time > self.rip_end - 1e-9):
                self.rip_debuff = False

                if self.log:
                    self.combat_log.append(
                        self.gen_log(self.rip_end, 'Rip', 'falls off')
                    )

            # Activate or deactivate trinkets if appropriate
            for trinket in self.trinkets:
                dmg_done += trinket.update(time, self.player, self)

            # Check if a melee swing happens at this time
            if time == self.swing_times[0]:
                dmg_done += self.player.swing()
                self.swing_times.pop(0)

                if self.log:
                    self.combat_log.append(
                        ['%.3f' % time] + self.player.combat_log
                    )

            # Check if an energy/spirit tick happens at this time
            if time == energy_tick_times[0]:
                self.player.energy = (
                    min(100, self.player.energy + 20) * self.player.cat_form
                )
                self.player.regen_mana()
                energy_tick_times.pop(0)

                if self.log:
                    self.combat_log.append(
                        self.gen_log(time, 'energy tick', '')
                    )

            # Determine next energy tick
            next_tick = energy_tick_times[0]

            # Check if we're able to act, and if so execute the optimal cast.
            self.player.combat_log = None

            if self.player.gcd < 1e-9:
                dmg_done += self.execute_rotation(time, next_tick)

            # Append player's log to running combat log
            if self.log and self.player.combat_log:
                self.combat_log.append(
                    ['%.3f' % time] + self.player.combat_log
                )

            # If we entered caster form, Tiger's Fury fell off
            if self.params['tigers_fury'] and (self.player.gcd == 1.5):
                self.drop_tigers_fury(time)

            # If a trinket proc occurred from a swing or special, apply it
            for trinket in self.trinkets:
                dmg_done += trinket.update(time, self.player, self)

            # If a proc ended at this timestep, remove it from the list
            if self.proc_end_times and (time == self.proc_end_times[0]):
                self.proc_end_times.pop(0)

            # Log current parameters
            times.append(time)
            damage.append(dmg_done)
            energy.append(self.player.energy)
            combos.append(self.player.combo_points)

            # Update time
            previous_time = time
            next_swing = self.swing_times[0]

            if self.player.gcd > 1e-9:
                time = min(time + self.player.gcd, next_swing, next_tick)
            else:
                time = min(next_swing, next_tick)

            if self.rip_debuff:
                time = min(time, self.rip_ticks[0])
            if self.proc_end_times:
                time = min(time, self.proc_end_times[0])

        # Replace logged Rip damage with the actual value realized in the run
        self.player.dmg_breakdown['Rip']['damage'] = rip_damage

        # Perform a final update on trinkets at the exact fight end for
        # accurate uptime calculations. Manually deactivate any trinkets that
        # are still up, and consolidate the aura uptimes.
        aura_stats = []

        for trinket in self.trinkets:
            trinket.update(self.fight_length, self.player, self)

            try:
                if trinket.active:
                    trinket.deactivate(
                        self.player, self, time=self.fight_length
                    )

                aura_stats.append(
                    [trinket.proc_name, trinket.num_procs, trinket.uptime]
                )
            except AttributeError:
                pass

        output = (
            times, damage, energy, combos, self.player.dmg_breakdown,
            aura_stats
        )

        if self.log:
            output += (self.combat_log,)

        return output

    def iterate(self, *args):
        """Perform one iteration of a multi-replicate calculation with a
        randomized fight length.

        Returns:
            avg_dps (float): Average DPS on this iteration.
            dmg_breakdown (dict): Breakdown of cast count and damage done by
                each player ability on this iteration.
            aura_stats (list of lists): Breakdown of proc count and total
                uptime of each player cooldown on this iteration.
            time_to_oom (float): Time at which player went oom in this
                iteration. If the player did not oom, then the fight length
                used in this iteration will be returned instead.
        """
        # Since we're getting the same snapshot of the Simulation object
        # when multiple iterations are run in parallel, we need to generate a
        # new random seed.
        np.random.seed()

        # Randomize fight length to avoid haste clipping effects. We will
        # use a normal distribution centered around the target length, with
        # a standard deviation of 1 second (unhasted swing timer). Impact
        # of the choice of distribution needs to be assessed...
        base_fight_length = self.fight_length
        randomized_fight_length = base_fight_length + np.random.randn()
        self.fight_length = randomized_fight_length

        _, damage, _, _, dmg_breakdown, aura_stats = self.run()
        avg_dps = np.sum(damage) / self.fight_length
        self.fight_length = base_fight_length

        if self.time_to_oom is None:
            oom_time = randomized_fight_length
        else:
            oom_time = self.time_to_oom

        return avg_dps, dmg_breakdown, aura_stats, oom_time

    def run_replicates(self, num_replicates, detailed_output=False):
        """Perform several runs of the simulation in order to collect
        statistics on performance.

        Arguments:
            num_replicates (int): Number of replicates to run.
            detailed_output (bool): Whether to consolidate details about cast
                and mana statistics in addition to DPS values. Defaults False.

        Returns:
            dps_vals (np.ndarray): Array containing average DPS of each run.
            cast_summary (collections.OrderedDict): Dictionary containing
                averaged statistics for the number of casts and total damage
                done by each player ability over the simulated fight length.
                Output only if detailed_output == True.
            aura_summary (list of lists): Averaged statistics for the number of
                procs and total uptime of each player cooldown over the
                simulated fight length. Output only if detailed_output == True.
            oom_times (np.ndarray): Array containing times at which the player
                went oom in each run. Output only if detailed_output == True.
                If the player did not oom in a run, the corresponding entry
                will be the total fight length.
        """
        # Make sure damage and mana parameters are up to date
        self.player.calc_damage_params(**self.params)
        self.player.set_mana_regen()

        # Run replicates and consolidate results
        dps_vals = np.zeros(num_replicates)

        if detailed_output:
            oom_times = np.zeros(num_replicates)

        # Create pool of workers to run replicates in parallel
        pool = multiprocessing.Pool(processes=psutil.cpu_count(logical=False))
        i = 0

        for output in pool.imap(self.iterate, range(num_replicates)):
            avg_dps, dmg_breakdown, aura_stats, time_to_oom = output
            dps_vals[i] = avg_dps

            if not detailed_output:
                i += 1
                continue

            # Consolidate damage breakdown for the fight
            if i == 0:
                cast_sum = copy.deepcopy(dmg_breakdown)
                aura_sum = copy.deepcopy(aura_stats)
            else:
                for ability in cast_sum:
                    for key in cast_sum[ability]:
                        val = dmg_breakdown[ability][key]
                        cast_sum[ability][key] = (
                            (cast_sum[ability][key] * i + val) / (i + 1)
                        )
                for row in range(len(aura_sum)):
                    for col in [1, 2]:
                        val = aura_stats[row][col]
                        aura_sum[row][col] = (
                            (aura_sum[row][col] * i + val) / (i + 1)
                        )

            # Consolidate oom time
            oom_times[i] = time_to_oom
            i += 1

        pool.close()

        if not detailed_output:
            return dps_vals

        return dps_vals, cast_sum, aura_sum, oom_times

    def calc_deriv(self, num_replicates, param, increment, base_dps):
        """Calculate DPS increase after incrementing a player stat.

        Arguments:
            num_replicates (int): Number of replicates to run.
            param (str): Player attribute to increment.
            increment (float): Magnitude of stat increment.
            base_dps (float): Pre-calculated base DPS before stat increments.

        Returns:
            dps_delta (float): Average DPS increase after the stat increment.
                The Player attribute will be reset to its original value once
                the calculation is finished.
        """
        # Increment the stat
        original_value = getattr(self.player, param)
        setattr(self.player, param, original_value + increment)

        # Calculate DPS
        dps_vals = self.run_replicates(num_replicates)
        avg_dps = np.mean(dps_vals)

        # Reset the stat to original value
        setattr(self.player, param, original_value)
        return avg_dps - base_dps

    def calc_stat_weights(self, num_replicates, base_dps=None):
        """Calculate performance derivatives for AP, hit, crit, and haste.

        Arguments:
            num_replicates (int): Number of replicates to run.
            base_dps (float): If provided, use a pre-calculated value for the
                base DPS before stat increments. Defaults to calculating base
                DPS from scratch.

        Returns:
            dps_deltas (dict): Dictionary containing DPS increase from 1 AP,
                1% hit, 1% crit, and 1% haste.
            stat_weights (dict): Dictionary containing normalized stat weights
                for 1% hit, 1% crit, and 1% haste relative to 1 AP.
        """
        # First store base DPS and deltas after each stat increment
        dps_deltas = {}

        if base_dps is None:
            dps_vals = self.run_replicates(num_replicates)
            base_dps = np.mean(dps_vals)

        # For all stats, we will use a much larger increment than +1 in order 
        # to see sufficient DPS increases above the simulation noise. We will
        # then linearize the increase down to a +1 increment for weight
        # calculation. This approximation is accurate as long as DPS is linear
        # in each stat up to the larger increment that was used.

        # For AP, we will use an increment of +80 AP
        dps_deltas['1 AP'] = 1.0/80.0 * self.calc_deriv(
            num_replicates, 'attack_power', 80, base_dps
        )

        # For hit and crit, we will use an increment of 2%.

        # For hit, we reduce miss chance by 2% if well below hit cap, and
        # increase miss chance by 2% when already capped or close.
        sign = 1 - 2 * int(self.player.miss_chance > 0.02)
        dps_deltas['1% hit'] = -0.5 * sign * self.calc_deriv(
            num_replicates, 'miss_chance', sign * 0.02, base_dps
        )

        # Crit is a simple increment
        dps_deltas['1% crit'] = 0.5 * self.calc_deriv(
            num_replicates, 'crit_chance', 0.02, base_dps
        )

        # For haste we will use an increment of 4%. (Note that this is 4% in
        # one slot and not four individual 1% buffs.) We implement the
        # increment by reducing the player swing timer.
        swing_delta = self.player.swing_timer * 0.04 / 1.04
        dps_deltas['1% haste'] = 0.25 * self.calc_deriv(
            num_replicates, 'swing_timer', -swing_delta, base_dps
        )

        # For weapon damage, we use an increment of 12
        dps_deltas['1 Weapon Damage'] = 1./12. * self.calc_deriv(
            num_replicates, 'bonus_damage', 12, base_dps
        )

        # Calculate normalized stat weights
        stat_weights = {}

        for stat in dps_deltas:
            if stat != '1 AP':
                stat_weights[stat] = dps_deltas[stat] / dps_deltas['1 AP']

        return dps_deltas, stat_weights

    def calc_mana_weights(self, num_replicates, base_dps, dps_per_AP):
        """Calculate weights for mana stats in situations where the player goes
        oom before the end of the fight. It is assumed that the regular stat
        weights have already been calculated prior to calling this method.

        Arguments:
            num_replicates (int): Number of replicates to run.
            base_dps (float): Average base DPS before stat increments.
            dps_per_AP (float): DPS added by 1 AP. This is output by the
                calc_stat_weights() method, and is used to normalize the mana
                weights.

        Returns:
            dps_deltas (dict): Dictionary containing DPS increase from 1 Int,
                1 Spirit, and 1 mp5. Int and Spirit contributions are not
                boosted by ZG buff or Blessing of Kings, and should be adjusted
                accordingly.
            stat_weights (dict): Dictionary containing normalized stat weights
                for 1 Int, 1 Spirit, and 1 mp5 relative to 1 AP.
        """
        dps_deltas = {}

        # For mana weight, increment player mana pool by one shift's worth
        dps_deltas['1 Int'] = 15. / self.player.shift_cost * self.calc_deriv(
            num_replicates, 'mana_pool', self.player.shift_cost, base_dps
        )

        # For spirit weight, calculate how much spirit regens an additional 
        # full shift's worth of mana over the course of Innervate.
        base_regen_delta = self.player.shift_cost / 10 / 5
        spirit_delta = base_regen_delta * 5
        dps_deltas['1 Spirit'] = 1.0 / spirit_delta * self.calc_deriv(
            num_replicates, 'spirit', spirit_delta, base_dps
        )

        # Same thing for mp5, except we integrate over the full fight length
        delta_mp5 = np.ceil(self.player.shift_cost / (self.fight_length / 5))
        dps_deltas['1 mp5'] = 1.0 / delta_mp5 * self.calc_deriv(
            num_replicates, 'mp5', delta_mp5, base_dps
        )

        # Calculate normalized stat weights
        stat_weights = {}

        for stat in ['1 Int', '1 Spirit', '1 mp5']:
            stat_weights[stat] = dps_deltas[stat] / dps_per_AP

        return dps_deltas, stat_weights