sc_death_knight.cpp - simulationcraft - World of Warcraft DPS Simulator

Source path: svn/ trunk/ engine/ sc_death_knight.cpp
‹r10942
r10996
// ==========================================================================
// Dedmonwakeen's DPS-DPM Simulator.
// Send questions to natehieter@gmail.com
// ==========================================================================

#include "simulationcraft.h"

struct dancing_rune_weapon_pet_t;

// ==========================================================================
// Death Knight Runes
// ==========================================================================

enum rune_type
{
  RUNE_TYPE_NONE=0, RUNE_TYPE_BLOOD, RUNE_TYPE_FROST, RUNE_TYPE_UNHOLY, RUNE_TYPE_DEATH, RUNE_TYPE_WASDEATH=8
};

const char *rune_symbols = "!bfu!!";

#define RUNE_TYPE_MASK     3
#define RUNE_SLOT_MAX      6

#define RUNIC_POWER_REFUND  0.9

// These macros simplify using the result of count_runes(), which
// returns a number of the form 0x000AABBCC where AA is the number of
// Unholy runes, BB is the number of Frost runes, and CC is the number
// of Blood runes.
#define GET_BLOOD_RUNE_COUNT(x)  ((x >>  0) & 0xff)
#define GET_FROST_RUNE_COUNT(x)  ((x >>  8) & 0xff)
#define GET_UNHOLY_RUNE_COUNT(x) ((x >> 16) & 0xff)

enum rune_state { STATE_DEPLETED, STATE_REGENERATING, STATE_FULL };

struct dk_rune_t
{
  int        type;
  rune_state state;
  double     value;   // 0.0 to 1.0, with 1.0 being full
  int        slot_number;
  bool       permanent_death_rune;
  dk_rune_t* paired_rune;

  dk_rune_t() : type( RUNE_TYPE_NONE ), state( STATE_FULL ), value( 0.0 ), permanent_death_rune( false ), paired_rune( NULL ) {}

  bool is_death()        const { return ( type & RUNE_TYPE_DEATH ) != 0                ; }
  bool is_blood()        const { return ( type & RUNE_TYPE_MASK  ) == RUNE_TYPE_BLOOD  ; }
  bool is_unholy()       const { return ( type & RUNE_TYPE_MASK  ) == RUNE_TYPE_UNHOLY ; }
  bool is_frost()        const { return ( type & RUNE_TYPE_MASK  ) == RUNE_TYPE_FROST  ; }
  bool is_ready()        const { return state == STATE_FULL                            ; }
  bool is_depleted()     const { return state == STATE_DEPLETED                        ; }
  bool is_regenerating() const { return state == STATE_REGENERATING                    ; }
  int  get_type()        const { return type & RUNE_TYPE_MASK                          ; }

  void regen_rune( player_t* p, timespan_t periodicity );

  void make_permanent_death_rune()
  {
    permanent_death_rune = true;
    type |= RUNE_TYPE_DEATH;
  }

  void consume( bool convert )
  {
    assert ( value >= 1.0 );
    if ( permanent_death_rune )
    {
      type |= RUNE_TYPE_DEATH;
    }
    else
    {
      type = ( type & RUNE_TYPE_MASK ) | ( ( type << 1 ) & RUNE_TYPE_WASDEATH ) | ( convert ? RUNE_TYPE_DEATH : 0 );
    }
    value = 0.0;
    state = STATE_DEPLETED;
  }

  void fill_rune()
  {
    value = 1.0;
    state = STATE_FULL;
  }

  void reset()
  {
    value = 1.0;
    state = STATE_FULL;
    type = type & RUNE_TYPE_MASK;
    if ( permanent_death_rune )
    {
      type |= RUNE_TYPE_DEATH;
    }
  }
};

// ==========================================================================
// Death Knight
// ==========================================================================

enum death_knight_presence { PRESENCE_BLOOD=1, PRESENCE_FROST, PRESENCE_UNHOLY=4 };

struct death_knight_targetdata_t : public targetdata_t
{
  dot_t* dots_blood_plague;
  dot_t* dots_death_and_decay;
  dot_t* dots_frost_fever;

  buff_t* debuffs_ebon_plaguebringer;

  int diseases()
  {
    int disease_count = 0;
    if ( debuffs_ebon_plaguebringer -> check() ) disease_count++;
    if ( dots_blood_plague -> ticking ) disease_count++;
    if ( dots_frost_fever  -> ticking ) disease_count++;
    return disease_count;
  }

  death_knight_targetdata_t( player_t* source, player_t* target );
};

void register_death_knight_targetdata( sim_t* sim )
{
  player_type t = DEATH_KNIGHT;
  typedef death_knight_targetdata_t type;

  REGISTER_DOT( blood_plague );
  REGISTER_DOT( death_and_decay );
  REGISTER_DOT( frost_fever );

  REGISTER_DEBUFF( ebon_plaguebringer );
}

struct death_knight_t : public player_t
{
  // Active
  int       active_presence;
  action_t* active_blood_caked_blade;
  action_t* active_unholy_blight;

  // Buffs
  buff_t* buffs_blood_presence;
  buff_t* buffs_bloodworms;
  buff_t* buffs_bone_shield;
  buff_t* buffs_crimson_scourge;
  buff_t* buffs_dancing_rune_weapon;
  buff_t* buffs_dark_transformation;
  buff_t* buffs_frost_presence;
  buff_t* buffs_killing_machine;
  buff_t* buffs_pillar_of_frost;
  buff_t* buffs_rime;
  buff_t* buffs_rune_of_cinderglacier;
  buff_t* buffs_rune_of_razorice;
  buff_t* buffs_rune_of_the_fallen_crusader;
  buff_t* buffs_rune_strike;
  buff_t* buffs_runic_corruption;
  buff_t* buffs_scent_of_blood;
  buff_t* buffs_shadow_infusion;
  buff_t* buffs_sudden_doom;
  buff_t* buffs_tier11_4pc_melee;
  buff_t* buffs_tier13_4pc_melee;
  buff_t* buffs_unholy_presence;

  // Cooldowns
  cooldown_t* cooldowns_howling_blast;

  // Diseases
  spell_t* blood_plague;
  spell_t* frost_fever;

  // Gains
  gain_t* gains_butchery;
  gain_t* gains_chill_of_the_grave;
  gain_t* gains_frost_presence;
  gain_t* gains_horn_of_winter;
  gain_t* gains_improved_frost_presence;
  gain_t* gains_might_of_the_frozen_wastes;
  gain_t* gains_power_refund;
  gain_t* gains_scent_of_blood;
  gain_t* gains_tier12_2pc_melee;
  gain_t* gains_rune;
  gain_t* gains_rune_unholy;
  gain_t* gains_rune_blood;
  gain_t* gains_rune_frost;
  gain_t* gains_rune_unknown;
  gain_t* gains_runic_empowerment;
  gain_t* gains_runic_empowerment_blood;
  gain_t* gains_runic_empowerment_unholy;
  gain_t* gains_runic_empowerment_frost;
  gain_t* gains_empower_rune_weapon;
  gain_t* gains_blood_tap;
  // only useful if the blood rune charts are enabled
  // charts are currently disabled so commenting out
  // gain_t* gains_blood_tap_blood;

  // Glyphs
  struct glyphs_t
  {
    // Prime
    glyph_t* death_and_decay;
    glyph_t* death_coil;
    glyph_t* death_strike;
    glyph_t* frost_strike;
    glyph_t* heart_strike;
    glyph_t* howling_blast;
    glyph_t* icy_touch;
    glyph_t* obliterate;
    glyph_t* raise_dead;
    glyph_t* rune_strike;
    glyph_t* scourge_strike;

    // Minor
    glyph_t* horn_of_winter;

    glyphs_t() { memset( ( void* ) this, 0x0, sizeof( glyphs_t ) ); }
  };
  glyphs_t glyphs;

  // Options
  std::string unholy_frenzy_target_str;

  // Spells
  struct spells_t
  {
    // Passives
    spell_id_t* blood_of_the_north;
    spell_id_t* blood_rites;
    spell_id_t* icy_talons;
    spell_id_t* master_of_ghouls;
    spell_id_t* plate_specialization;
    spell_id_t* reaping;
    spell_id_t* runic_empowerment;
    spell_id_t* unholy_might;
    spell_id_t* veteran_of_the_third_war;

    // Masteries
    mastery_t* dreadblade;
    mastery_t* frozen_heart;

    spells_t() { memset( ( void* ) this, 0x0, sizeof( spells_t ) ); }
  };
  spells_t spells;

  // Pets and Guardians
  pet_t* active_army_ghoul;
  pet_t* active_bloodworms;
  dancing_rune_weapon_pet_t* active_dancing_rune_weapon;
  pet_t* active_ghoul;
  pet_t* active_gargoyle;

  // Procs
  proc_t* proc_runic_empowerment;
  proc_t* proc_runic_empowerment_wasted;
  proc_t* proc_oblit_killing_machine;
  proc_t* proc_fs_killing_machine;

  // RNGs
  rng_t* rng_blood_caked_blade;
  rng_t* rng_might_of_the_frozen_wastes;
  rng_t* rng_threat_of_thassarian;

  // Runes
  struct runes_t
  {
    dk_rune_t slot[RUNE_SLOT_MAX];

    runes_t()
    {
      // 6 runes, paired blood, frost and unholy
      slot[0].type = slot[1].type = RUNE_TYPE_BLOOD;
      slot[2].type = slot[3].type = RUNE_TYPE_FROST;
      slot[4].type = slot[5].type = RUNE_TYPE_UNHOLY;
      // each rune pair is paired with each other
      slot[0].paired_rune = &slot[1]; slot[1].paired_rune = &slot[0];
      slot[2].paired_rune = &slot[3]; slot[3].paired_rune = &slot[2];
      slot[4].paired_rune = &slot[5]; slot[5].paired_rune = &slot[4];
      // give each rune a slot number
      for ( int i = 0; i < RUNE_SLOT_MAX; ++i ) { slot[i].slot_number = i; }
    }
    void reset() { for ( int i = 0; i < RUNE_SLOT_MAX; ++i ) slot[i].reset(); }
  };
  runes_t _runes;

  // Talents
  struct talents_t
  {
    // Blood
    talent_t* abominations_might;
    talent_t* bladed_armor;
    talent_t* blood_caked_blade;
    talent_t* blood_parasite;
    talent_t* bone_shield;
    talent_t* butchery;
    talent_t* crimson_scourge;
    talent_t* dancing_rune_weapon;
    talent_t* improved_blood_presence;
    talent_t* improved_blood_tap;
    talent_t* improved_death_strike;
    talent_t* scent_of_blood;

    // Frost
    talent_t* annihilation;
    talent_t* brittle_bones;
    talent_t* chill_of_the_grave;
    talent_t* endless_winter;
    talent_t* howling_blast;
    talent_t* improved_frost_presence;
    talent_t* improved_icy_talons;
    talent_t* killing_machine;
    talent_t* merciless_combat;
    talent_t* might_of_the_frozen_wastes;
    talent_t* nerves_of_cold_steel;
    talent_t* pillar_of_frost;
    talent_t* rime;
    talent_t* runic_power_mastery;
    talent_t* threat_of_thassarian;
    talent_t* toughness;

    // Unholy
    talent_t* contagion;
    talent_t* dark_transformation;
    talent_t* ebon_plaguebringer;
    talent_t* epidemic;
    talent_t* improved_unholy_presence;
    talent_t* morbidity;
    talent_t* rage_of_rivendare;
    talent_t* runic_corruption;
    talent_t* shadow_infusion;
    talent_t* sudden_doom;
    talent_t* summon_gargoyle;
    talent_t* unholy_blight;
    talent_t* unholy_frenzy;
    talent_t* virulence;

    talents_t() { memset( ( void* ) this, 0x0, sizeof( talents_t ) ); }
  };
  talents_t talents;

  // Uptimes
  benefit_t* uptimes_rp_cap;

  double tier12_4pc_melee_value;

  death_knight_t( sim_t* sim, const std::string& name, race_type r = RACE_NONE ) :
    player_t( sim, DEATH_KNIGHT, name, r )
  {
    if ( race == RACE_NONE ) race = RACE_NIGHT_ELF;

    tree_type[ DEATH_KNIGHT_BLOOD  ] = TREE_BLOOD;
    tree_type[ DEATH_KNIGHT_FROST  ] = TREE_FROST;
    tree_type[ DEATH_KNIGHT_UNHOLY ] = TREE_UNHOLY;

    // Active
    active_presence            = 0;
    active_blood_caked_blade   = NULL;
    active_unholy_blight       = NULL;
    blood_plague = NULL;
    frost_fever  = NULL;

    // Pets and Guardians
    active_army_ghoul          = NULL;
    active_bloodworms          = NULL;
    active_dancing_rune_weapon = NULL;
    active_ghoul               = NULL;
    active_gargoyle            = NULL;

    cooldowns_howling_blast = get_cooldown( "howling_blast" );

    create_talents();
    create_glyphs();
    create_options();

    default_distance = 0;
  }

  // Character Definition
  virtual targetdata_t* new_targetdata( player_t* source, player_t* target ) {return new death_knight_targetdata_t( source, target );}
  virtual void      init();
  virtual void      init_talents();
  virtual void      init_spells();
  virtual void      init_actions();
  virtual void      init_enchant();
  virtual void      init_rng();
  virtual void      init_defense();
  virtual void      init_base();
  virtual void      init_scaling();
  virtual void      init_buffs();
  virtual void      init_values();
  virtual void      init_gains();
  virtual void      init_procs();
  virtual void      init_resources( bool force );
  virtual void      init_benefits();
  virtual double    composite_armor_multiplier() const;
  virtual double    composite_attack_haste() const;
  virtual double    composite_attack_hit() const;
  virtual double    composite_attack_power() const;
  virtual double    composite_attribute_multiplier( int attr ) const;
  virtual double    matching_gear_multiplier( const attribute_type attr ) const;
  virtual double    composite_spell_hit() const;
  virtual double    composite_tank_parry() const;
  virtual double    composite_player_multiplier( const school_type school, action_t* a = NULL ) const;
  virtual double    composite_tank_crit( const school_type school ) const;
  virtual void      regen( timespan_t periodicity );
  virtual void      reset();
  virtual double    assess_damage( double amount, const school_type school, int    dmg_type, int result, action_t* a );
  virtual void      combat_begin();
  virtual void      create_options();
  virtual action_t* create_action( const std::string& name, const std::string& options );
  virtual action_expr_t* create_expression( action_t*, const std::string& name );
  virtual pet_t*    create_pet( const std::string& name, const std::string& type = std::string() );
  virtual void      create_pets();
  virtual int       decode_set( item_t& item );
  virtual int       primary_resource() const { return RESOURCE_RUNIC; }
  virtual int       primary_role() const;
  virtual void      trigger_runic_empowerment();
  virtual int       runes_count( rune_type rt, bool include_death, int position );
  virtual double    runes_cooldown_any( rune_type rt, bool include_death, int position );
  virtual double    runes_cooldown_all( rune_type rt, bool include_death, int position );
  virtual double    runes_cooldown_time( dk_rune_t* r );
  virtual bool      runes_depleted( rune_type rt, int position );

  void reset_gcd()
  {
    for ( action_t* a=action_list; a; a = a -> next )
    {
      if ( a -> trigger_gcd != timespan_t::zero ) a -> trigger_gcd = base_gcd;
    }
  }
};

death_knight_targetdata_t::death_knight_targetdata_t( player_t* source, player_t* target )
  : targetdata_t( source, target )
{
  death_knight_t* p = this->source -> cast_death_knight();
  debuffs_ebon_plaguebringer  = add_aura( new buff_t( this, 65142, "ebon_plaguebringer_track", -1, timespan_t::min, true ) );
  debuffs_ebon_plaguebringer -> buff_duration += p -> talents.epidemic -> effect1().time_value();
}

static void log_rune_status( death_knight_t* p )
{
  std::string rune_str;
  for ( int j = 0; j < RUNE_SLOT_MAX; ++j )
  {
    char rune_letter = rune_symbols[p -> _runes.slot[j].get_type()];
    if ( p -> _runes.slot[j].is_death() )
      rune_letter = 'd';

    if ( p -> _runes.slot[j].is_ready() )
      rune_letter = toupper( rune_letter );
    rune_str += rune_letter;
  }
  log_t::output( p -> sim, "%s runes: %s", p -> name(), rune_str.c_str() );
}

void dk_rune_t::regen_rune( player_t* p, timespan_t periodicity )
{
  // If the other rune is already regening, we don't
  // but if both are full we still continue on to record resource gain overflow
  if ( state == STATE_DEPLETED &&   paired_rune -> state == STATE_REGENERATING ) return;
  if ( state == STATE_FULL     && ! ( paired_rune -> state == STATE_FULL )     ) return;

  // Base rune regen rate is 10 seconds; we want the per-second regen
  // rate, so divide by 10.0.  Haste is a multiplier (so 30% haste
  // means composite_attack_haste is 1/1.3), so we invert it.  Haste
  // linearly scales regen rate -- 100% haste means a rune regens in 5
  // seconds, etc.
  double runes_per_second = 1.0 / 10.0 / p -> composite_attack_haste();

  death_knight_t* o = p -> cast_death_knight();

  if ( o -> buffs_blood_presence -> check() && o -> talents.improved_blood_presence -> rank() )
    runes_per_second *= 1.0 + o -> talents.improved_blood_presence -> effect3().percent();

  // Unholy Presence's 10% (or, talented, 15%) increase is factored in elsewhere as melee haste.
  if ( o -> buffs_runic_corruption -> up() )
    runes_per_second *= 1.0 + ( o -> talents.runic_corruption -> effect1().percent() );

  double regen_amount = periodicity.total_seconds() * runes_per_second;

  // record rune gains and overflow
  gain_t* gains_rune      = o -> gains_rune         ;
  gain_t* gains_rune_type =
    is_frost()            ? o -> gains_rune_frost   :
    is_blood()            ? o -> gains_rune_blood   :
    is_unholy()           ? o -> gains_rune_unholy  :
                            o -> gains_rune_unknown ; // should never happen, so if you've seen this in a report happy bug hunting

  // full runes don't regen. if both full, record half of overflow, as the other rune will record the other half
  if ( state == STATE_FULL )
  {
    if ( paired_rune -> state == STATE_FULL )
    {
      gains_rune_type -> add( 0, regen_amount * 0.5 );
      gains_rune      -> add( 0, regen_amount * 0.5 );
    }
    return;
  }

  // Chances are, we will overflow by a small amount.  Toss extra
  // overflow into our paired rune if it is regenerating or depleted.
  value += regen_amount;
  double overflow = 0.0;
  if ( value > 1.0 )
  {
    overflow = value - 1.0;
    value = 1.0;
  }

  if ( value >= 1.0 )
    state = STATE_FULL;
  else
    state = STATE_REGENERATING;

  if ( overflow > 0.0 && ( paired_rune -> state == STATE_REGENERATING || paired_rune -> state == STATE_DEPLETED ) )
  {
    // we shouldn't ever overflow the paired rune, but take care just in case
    paired_rune -> value += overflow;
    if ( paired_rune -> value > 1.0 )
    {
      overflow = paired_rune -> value - 1.0;
      paired_rune -> value = 1.0;
    }
    if ( paired_rune -> value >= 1.0 )
      paired_rune -> state = STATE_FULL;
    else
      paired_rune -> state = STATE_REGENERATING;
  }
  gains_rune_type -> add( regen_amount - overflow, overflow );
  gains_rune      -> add( regen_amount - overflow, overflow );

  if ( p -> sim -> debug )
    log_t::output( p -> sim, "rune %d has %.2f regen time (%.3f per second) with %.2f%% haste",
                   slot_number, 1 / runes_per_second, runes_per_second, 100 * ( 1 / p -> composite_attack_haste() - 1 ) );

  if ( state == STATE_FULL )
  {
    if ( p -> sim -> log )
      log_rune_status( o );

    if ( is_death() )
      o -> buffs_tier11_4pc_melee -> trigger();

    if ( p -> sim -> debug )
      log_t::output( p -> sim, "rune %d regens to full", slot_number );
  }
}


// ==========================================================================
// Dancing Rune Weapon
// ==========================================================================

struct dancing_rune_weapon_pet_t : public pet_t
{
  dot_t* dots_drw_blood_plague;
  dot_t* dots_drw_frost_fever;

  int drw_diseases( player_t* /* t */ )
  {
    int drw_disease_count = 0;
    if ( dots_drw_blood_plague -> ticking ) drw_disease_count++;
    if ( dots_drw_frost_fever  -> ticking ) drw_disease_count++;
    return drw_disease_count;
  }

  struct drw_spell_t : public spell_t
  {
    drw_spell_t( const char* n, uint32_t id, dancing_rune_weapon_pet_t* p ) :
      spell_t( n, id, p )
    { }

    virtual bool ready() { return false; }
  };

  struct drw_blood_boil_t : public drw_spell_t
  {
    drw_blood_boil_t( dancing_rune_weapon_pet_t* p ) :
      drw_spell_t( "blood_boil", 48721, p )
    {
      background       = true;
      trigger_gcd      = timespan_t::zero;
      aoe              = -1;
      may_crit         = true;
      direct_power_mod = 0.08;
    }

    void target_debuff( player_t* t, int dmg_type )
    {
      dancing_rune_weapon_pet_t* p = ( dancing_rune_weapon_pet_t* ) player;
      drw_spell_t::target_debuff( t, dmg_type );

      base_dd_adder = ( p -> drw_diseases( t ) ? 95 : 0 );
      direct_power_mod  = 0.08 + ( p -> drw_diseases( t ) ? 0.035 : 0 );
    }
  };

  struct drw_blood_plague_t : public drw_spell_t
  {
    drw_blood_plague_t( dancing_rune_weapon_pet_t* p ) :
      drw_spell_t( "blood_plague", 59879, p )
    {
      death_knight_t* o = p -> owner -> cast_death_knight();

      background         = true;
      base_tick_time     = timespan_t::from_seconds( 3.0 );
      num_ticks          = 7 + util_t::talent_rank( o -> talents.epidemic -> rank(), 3, 1, 3, 4 );
      direct_power_mod   = 0.055 * 1.15;
      may_miss           = false;
      hasted_ticks       = false;
    }
  };

  struct drw_death_coil_t : public drw_spell_t
  {
    drw_death_coil_t( dancing_rune_weapon_pet_t* p ) :
      drw_spell_t( "death_coil", 47541, p )
    {
      death_knight_t* o = p -> owner -> cast_death_knight();

      background  = true;
      trigger_gcd = timespan_t::zero;
      direct_power_mod = 0.23;
      base_dd_min      = player -> dbc.effect_min( effect_id( 1 ), p -> level ); // Values are saved in a not automatically parsed sub-effect
      base_dd_max      = player -> dbc.effect_max( effect_id( 1 ), p -> level );
      base_multiplier *= 1 + o -> glyphs.death_coil -> effect1().percent();

      base_crit     += o -> sets -> set( SET_T11_2PC_MELEE ) -> effect1().percent();
    }
  };

  struct drw_attack_t : public attack_t
  {
    drw_attack_t( const char* n, uint32_t id, dancing_rune_weapon_pet_t* p, bool special=false ) :
      attack_t( n, id, p, 0, special )
    { }

    drw_attack_t( const char* n, dancing_rune_weapon_pet_t* p, int r=RESOURCE_NONE, const school_type s=SCHOOL_PHYSICAL, int t=TREE_NONE, bool special = false ) :
      attack_t( n, p, r, s, t, special )
    { }

    virtual bool ready() { return false; }
  };

  struct drw_death_strike_t : public drw_attack_t
  {
    drw_death_strike_t( dancing_rune_weapon_pet_t* p ) :
      drw_attack_t( "death_strike", 49998, p, true )
    {
      death_knight_t* o = p -> owner -> cast_death_knight();

      background  = true;
      trigger_gcd = timespan_t::zero;

      base_crit       +=     o -> talents.improved_death_strike -> mod_additive( P_CRIT );
      base_multiplier *= 1 + o -> talents.improved_death_strike -> mod_additive( P_GENERIC );
    }
  };

  struct drw_frost_fever_t : public drw_spell_t
  {
    drw_frost_fever_t( dancing_rune_weapon_pet_t* p ) :
      drw_spell_t( "frost_fever", 59921, p )
    {
      death_knight_t* o = p -> owner -> cast_death_knight();

      background        = true;
      trigger_gcd       = timespan_t::zero;
      base_tick_time    = timespan_t::from_seconds( 3.0 );
      hasted_ticks      = false;
      may_miss          = false;
      num_ticks         = 7 + util_t::talent_rank( o -> talents.epidemic -> rank(), 3, 1, 3, 4 );
      direct_power_mod *= 0.055 * 1.15;
      base_multiplier  *= 1.0 + o -> glyphs.icy_touch -> effect1().percent();
    }
  };

  struct drw_heart_strike_t : public drw_attack_t
  {
    drw_heart_strike_t( dancing_rune_weapon_pet_t* p ) :
      drw_attack_t( "heart_strike", 55050, p )
    {
      death_knight_t* o = p -> owner -> cast_death_knight();

      background          = true;
      aoe                 = 2;
      base_add_multiplier = 0.75;
      trigger_gcd         = timespan_t::zero;
      base_multiplier    *= 1 + o -> glyphs.heart_strike -> effect1().percent();
    }

    void target_debuff( player_t* t, int dmg_type )
    {
      dancing_rune_weapon_pet_t* p = ( dancing_rune_weapon_pet_t* ) player;
      drw_attack_t::target_debuff( t, dmg_type );

      target_multiplier *= 1 + p -> drw_diseases( t ) * effect3().percent();
    }
  };

  struct drw_icy_touch_t : public drw_spell_t
  {
    drw_icy_touch_t( dancing_rune_weapon_pet_t* p ) :
      drw_spell_t( "icy_touch", 45477, p )
    {
      background       = true;
      trigger_gcd      = timespan_t::zero;
      direct_power_mod = 0.2;
    }

    virtual void execute()
    {
      dancing_rune_weapon_pet_t* p = ( dancing_rune_weapon_pet_t* ) player;

      drw_spell_t::execute();

      if ( result_is_hit() )
      {
        if ( ! p -> drw_frost_fever )
          p -> drw_frost_fever = new drw_frost_fever_t( p );
        p -> drw_frost_fever -> execute();
      }
    }
  };

  struct drw_pestilence_t : public drw_spell_t
  {
    drw_pestilence_t( dancing_rune_weapon_pet_t* p ) :
      drw_spell_t( "pestilence", 50842, p )
    {
      trigger_gcd = timespan_t::zero;
      background = true;
    }
  };

  struct drw_plague_strike_t : public drw_attack_t
  {
    drw_plague_strike_t( dancing_rune_weapon_pet_t* p ) :
      drw_attack_t( "plague_strike", 45462, p, true )
    {
      background       = true;
      trigger_gcd      = timespan_t::zero;
      may_crit         = true;
    }

    virtual void execute()
    {
      dancing_rune_weapon_pet_t* p = ( dancing_rune_weapon_pet_t* ) player;

      drw_attack_t::execute();

      if ( result_is_hit() )
      {
        if ( ! p -> drw_blood_plague )
          p -> drw_blood_plague = new drw_blood_plague_t( p );
        p -> drw_blood_plague -> execute();
      }
    }
  };

  struct drw_melee_t : public drw_attack_t
  {
    drw_melee_t( dancing_rune_weapon_pet_t* p ) :
      drw_attack_t( "drw_melee", p, RESOURCE_NONE, SCHOOL_PHYSICAL, TREE_NONE, false )
    {
      weapon            = &( p -> owner -> main_hand_weapon );
      base_execute_time = weapon -> swing_time;
      base_dd_min       = 2; // FIXME: Should these be set?
      base_dd_max       = 322;
      may_crit          = true;
      background        = true;
      repeating         = true;
      weapon_power_mod *= 2.0; //Attack power scaling is unaffected by the DRW 50% penalty.
    }

    virtual bool ready()
    {
      return attack_t::ready();
    }
  };

  double snapshot_spell_crit, snapshot_attack_crit, haste_snapshot, speed_snapshot;
  spell_t*  drw_blood_boil;
  spell_t*  drw_blood_plague;
  spell_t*  drw_death_coil;
  attack_t* drw_death_strike;
  spell_t*  drw_frost_fever;
  attack_t* drw_heart_strike;
  spell_t*  drw_icy_touch;
  spell_t*  drw_pestilence;
  attack_t* drw_plague_strike;
  attack_t* drw_melee;

  dancing_rune_weapon_pet_t( sim_t* sim, player_t* owner ) :
    pet_t( sim, owner, "dancing_rune_weapon", true ),
    dots_drw_blood_plague( 0 ), dots_drw_frost_fever( 0 ),
    snapshot_spell_crit( 0.0 ), snapshot_attack_crit( 0.0 ),
    haste_snapshot( 1.0 ), speed_snapshot( 1.0 ), drw_blood_boil( 0 ), drw_blood_plague( 0 ),
    drw_death_coil( 0 ), drw_death_strike( 0 ), drw_frost_fever( 0 ),
    drw_heart_strike( 0 ), drw_icy_touch( 0 ), drw_pestilence( 0 ),
    drw_plague_strike( 0 ), drw_melee( 0 )
  {
    dots_drw_blood_plague  = get_dot( "blood_plague" );
    dots_drw_frost_fever   = get_dot( "frost_fever" );

    main_hand_weapon.type       = WEAPON_SWORD_2H;
    main_hand_weapon.min_dmg    = 685; // FIXME: Should these be hardcoded?
    main_hand_weapon.max_dmg    = 975;
    main_hand_weapon.swing_time = timespan_t::from_seconds( 3.3 );
  }

  virtual void init_base()
  {
    // Everything stays at zero.
    // DRW uses a snapshot of the DKs stats when summoned.
    drw_blood_boil    = new drw_blood_boil_t   ( this );
    drw_blood_plague  = new drw_blood_plague_t ( this );
    drw_death_coil    = new drw_death_coil_t   ( this );
    drw_death_strike  = new drw_death_strike_t ( this );
    drw_frost_fever   = new drw_frost_fever_t  ( this );
    drw_heart_strike  = new drw_heart_strike_t ( this );
    drw_icy_touch     = new drw_icy_touch_t    ( this );
    drw_pestilence    = new drw_pestilence_t   ( this );
    drw_plague_strike = new drw_plague_strike_t( this );
    drw_melee         = new drw_melee_t        ( this );
  }

  virtual double composite_attack_crit() const        { return snapshot_attack_crit; }
  virtual double composite_attack_haste() const       { return haste_snapshot; }
  virtual double composite_attack_speed() const       { return speed_snapshot; }
  virtual double composite_attack_power() const       { return attack_power; }
  virtual double composite_spell_crit() const         { return snapshot_spell_crit;  }

  virtual void summon( timespan_t duration=timespan_t::zero )
  {
    death_knight_t* o = owner -> cast_death_knight();
    pet_t::summon( duration );
    snapshot_spell_crit  = o -> composite_spell_crit();
    snapshot_attack_crit = o -> composite_attack_crit();
    haste_snapshot       = o -> composite_attack_haste();
    speed_snapshot       = o -> composite_attack_speed();
    attack_power         = o -> composite_attack_power() * o -> composite_attack_power_multiplier();
    drw_melee -> schedule_execute();
  }
};

namespace  // ANONYMOUS NAMESPACE ===========================================
{

// ==========================================================================
// Guardians
// ==========================================================================

// ==========================================================================
// Army of the Dead Ghoul
// ==========================================================================

struct army_ghoul_pet_t : public pet_t
{
  double snapshot_crit, snapshot_haste, snapshot_speed, snapshot_hit, snapshot_strength;

  army_ghoul_pet_t( sim_t* sim, player_t* owner ) :
    pet_t( sim, owner, "army_of_the_dead", true ),
    snapshot_crit( 0 ), snapshot_haste( 0 ), snapshot_speed( 0 ), snapshot_hit( 0 ), snapshot_strength( 0 )
  {
    main_hand_weapon.type       = WEAPON_BEAST;
    main_hand_weapon.min_dmg    = 228; // FIXME: Needs further testing
    main_hand_weapon.max_dmg    = 323; // FIXME: Needs further testing
    main_hand_weapon.swing_time = timespan_t::from_seconds( 2.0 );

    action_list_str = "snapshot_stats/auto_attack/claw";
  }

  struct army_ghoul_pet_attack_t : public attack_t
  {
    void _init_army_ghoul_pet_attack_t()
    {
      weapon = &( player -> main_hand_weapon );
      may_crit = true;
      base_multiplier *= 8.0; // 8 ghouls
    }

    army_ghoul_pet_attack_t( const char* n, army_ghoul_pet_t* p, const resource_type r=RESOURCE_ENERGY, bool special=true ) :
      attack_t( n, p, r, SCHOOL_PHYSICAL, TREE_NONE, special )
    {
      _init_army_ghoul_pet_attack_t();
    }

    army_ghoul_pet_attack_t( const char* n, uint32_t id, army_ghoul_pet_t* p, bool special=true ) :
      attack_t( n, id, p, TREE_NONE, special )
    {
      _init_army_ghoul_pet_attack_t();
    }
  };

  struct army_ghoul_pet_melee_t : public army_ghoul_pet_attack_t
  {
    army_ghoul_pet_melee_t( army_ghoul_pet_t* p ) :
      army_ghoul_pet_attack_t( "melee", p, RESOURCE_NONE, false )
    {
      base_execute_time = weapon -> swing_time;
      background        = true;
      repeating         = true;
      weapon_power_mod  = 0.0055 / weapon -> swing_time.total_seconds(); // FIXME: Needs further testing
    }
  };

  struct army_ghoul_pet_auto_attack_t : public army_ghoul_pet_attack_t
  {
    army_ghoul_pet_auto_attack_t( army_ghoul_pet_t* p ) :
      army_ghoul_pet_attack_t( "auto_attack", p )
    {
      weapon = &( p -> main_hand_weapon );
      p -> main_hand_attack = new army_ghoul_pet_melee_t( p );
      trigger_gcd = timespan_t::zero;
    }

    virtual void execute()
    {
      army_ghoul_pet_t* p = ( army_ghoul_pet_t* ) player -> cast_pet();
      p -> main_hand_attack -> schedule_execute();
    }

    virtual bool ready()
    {
      army_ghoul_pet_t* p = ( army_ghoul_pet_t* ) player -> cast_pet();
      return( p -> main_hand_attack -> execute_event == 0 ); // not swinging
    }
  };

  struct army_ghoul_pet_claw_t : public army_ghoul_pet_attack_t
  {
    army_ghoul_pet_claw_t( army_ghoul_pet_t* p ) :
      army_ghoul_pet_attack_t( "claw", 91776, p )
    {
      weapon_power_mod  = 0.0055 / weapon -> swing_time.total_seconds(); // FIXME: Needs further testing
    }
  };

  virtual void init_base()
  {
    // FIXME: Copied from the pet ghoul
    attribute_base[ ATTR_STRENGTH  ] = 476;
    attribute_base[ ATTR_AGILITY   ] = 3343;
    attribute_base[ ATTR_STAMINA   ] = 546;
    attribute_base[ ATTR_INTELLECT ] = 69;
    attribute_base[ ATTR_SPIRIT    ] = 116;

    base_attack_power = -20;
    initial_attack_power_per_strength = 2.0;
    initial_attack_power_per_agility  = 0.0;

    // Ghouls don't appear to gain any crit from agi, they may also just have none
    // initial_attack_crit_per_agility = rating_t::interpolate( level, 0.01/25.0, 0.01/40.0, 0.01/83.3 );

    resource_base[ RESOURCE_ENERGY ] = 100;
    base_energy_regen_per_second  = 10;
  }

  virtual double energy_regen_per_second() const
  {
    // Doesn't benefit from haste
    return base_energy_regen_per_second;
  }

  virtual double strength() const
  {
    death_knight_t* o = owner -> cast_death_knight();
    double a = attribute[ ATTR_STRENGTH ];
    // copied from the pet ghoul, tested in unholy and frost.
    double strength_scaling = 1.01 + o -> glyphs.raise_dead -> ok() * 0.4254;
    a += snapshot_strength * strength_scaling;
    a *= composite_attribute_multiplier( ATTR_STRENGTH );
    return a;
  }

  virtual void summon( timespan_t duration=timespan_t::zero )
  {
    death_knight_t* o = owner -> cast_death_knight();
    pet_t::summon( duration );
    snapshot_crit     = o -> composite_attack_crit();
    snapshot_haste    = o -> composite_attack_haste();
    snapshot_speed    = o -> composite_attack_speed();
    snapshot_hit      = o -> composite_attack_hit();
    snapshot_strength = o -> strength();
  }

  virtual double composite_attack_expertise() const
  {
    return ( ( 100.0 * snapshot_hit ) * 26.0 / 8.0 ) / 100.0; // Hit gains equal to expertise
  }

  virtual double composite_attack_crit() const { return snapshot_crit; }

  virtual double composite_attack_speed() const { return snapshot_speed; }

  virtual double composite_attack_haste() const { return snapshot_haste; }

  virtual double composite_attack_hit() const { return snapshot_hit; }

  virtual int primary_resource() const { return RESOURCE_ENERGY; }

  virtual action_t* create_action( const std::string& name, const std::string& options_str )
  {
    if ( name == "auto_attack"    ) return new  army_ghoul_pet_auto_attack_t( this );
    if ( name == "claw"           ) return new         army_ghoul_pet_claw_t( this );

    return pet_t::create_action( name, options_str );
  }

  timespan_t available() const
  {
    double energy = resource_current[ RESOURCE_ENERGY ];

    if ( energy > 40 )
      return timespan_t::from_seconds( 0.1 );

    return std::max(
      timespan_t::from_seconds( ( 40 - energy ) / energy_regen_per_second() ),
      timespan_t::from_seconds( 0.1 )
    );
  }
};

// ==========================================================================
// Bloodworms
// ==========================================================================
struct bloodworms_pet_t : public pet_t
{
  // FIXME: Level 80/85 values
  struct melee_t : public attack_t
  {
    melee_t( player_t* player ) :
      attack_t( "bloodworm_melee", player, RESOURCE_NONE, SCHOOL_PHYSICAL, TREE_NONE, false )
    {
      weapon = &( player -> main_hand_weapon );
      base_execute_time = weapon -> swing_time;
      base_dd_min = base_dd_max = 1;
      may_crit    = true;
      background  = true;
      repeating   = true;
    }
  };

  melee_t* melee;

  bloodworms_pet_t( sim_t* sim, player_t* owner ) :
    pet_t( sim, owner, "bloodworms", true /*guardian*/ )
  {
    main_hand_weapon.type       = WEAPON_BEAST;
    main_hand_weapon.min_dmg    = 20;
    main_hand_weapon.max_dmg    = 20;
    main_hand_weapon.swing_time = timespan_t::from_seconds( 2.0 );
  }

  virtual void init_base()
  {
    pet_t::init_base();

    // Stolen from Priest's Shadowfiend
    attribute_base[ ATTR_STRENGTH  ] = 145;
    attribute_base[ ATTR_AGILITY   ] =  38;
    attribute_base[ ATTR_STAMINA   ] = 190;
    attribute_base[ ATTR_INTELLECT ] = 133;

    health_per_stamina = 7.5;
    mana_per_intellect = 5;

    melee = new melee_t( this );
  }

  virtual void summon( timespan_t duration=timespan_t::zero )
  {
    pet_t::summon( duration );
    melee -> schedule_execute();
  }

  virtual int primary_resource() const { return RESOURCE_MANA; }
};

// ==========================================================================