From 3ce9c37c07e14e28a8fd20eb33eea0089833d4a4 Mon Sep 17 00:00:00 2001 From: vigo Date: Wed, 20 Mar 2024 16:38:49 +0100 Subject: [PATCH] [common] CreateWeaponProcDamage() is now using the proper critMultiplier for non-magic procs [common] "Shocking" equipment now always deals non-crit self-damage [common, core] Dismantle and Dragonbreath Chili procs can now properly crit, and Explosive use spell crit multiplier [hunter, warrior] next attack queue spells no longer have a ProcMask set [priest] Mind Sear and Shadow Word: Death can now crit [rogue] Envenom and Shuriken Toss were wrongly benefiting from Lethality --- sim/_paladin/talents.go | 11 +++++++---- sim/common/itemhelpers/weaponprocs.go | 8 +++++++- sim/common/sod/crafted/phase_2.go | 8 ++------ sim/common/sod/enchant_effects.go | 13 +++++------- sim/core/consumes.go | 23 +++++++++++++--------- sim/encounters/naxxramas/patchwerk10_ai.go | 3 ++- sim/encounters/naxxramas/patchwerk25_ai.go | 3 ++- sim/hunter/raptor_strike.go | 6 ++---- sim/hunter/serpent_sting.go | 2 +- sim/priest/devouring_plague.go | 5 ++--- sim/priest/mind_flay.go | 10 ++++------ sim/priest/mind_sear.go | 17 ++++++++-------- sim/priest/shadow_word_death.go | 8 +++++--- sim/priest/shadow_word_pain.go | 3 +-- sim/priest/void_plague.go | 5 ++--- sim/rogue/envenom.go | 3 ++- sim/rogue/shuriken_toss.go | 3 ++- sim/shaman/ancestral_awakening.go | 13 +++++++----- sim/shaman/ancestral_guidance.go | 3 ++- sim/shaman/water_totems.go | 3 ++- sim/warlock/corruption.go | 5 ++--- sim/warrior/heroic_strike_cleave.go | 6 ++---- sim/warrior/items.go | 2 -- 23 files changed, 85 insertions(+), 78 deletions(-) diff --git a/sim/_paladin/talents.go b/sim/_paladin/talents.go index 8b508c358e..ecd25efd2c 100644 --- a/sim/_paladin/talents.go +++ b/sim/_paladin/talents.go @@ -225,12 +225,15 @@ func (paladin *Paladin) applyArdentDefender() { // Spell to heal you when AD has procced; fire this before fatal damage so that a Death is not detected procHeal := paladin.RegisterSpell(core.SpellConfig{ - ActionID: core.ActionID{SpellID: 66233}, - SpellSchool: core.SpellSchoolHoly, - ProcMask: core.ProcMaskSpellHealing, - CritMultiplier: 1, // Assuming this can't really crit? + ActionID: core.ActionID{SpellID: 66233}, + SpellSchool: core.SpellSchoolHoly, + ProcMask: core.ProcMaskSpellHealing, + + CritMultiplier: 1, // Assuming this can't really crit? + ThreatMultiplier: 0.25, DamageMultiplier: 1, + ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { spell.CalcAndDealHealing(sim, &paladin.Unit, ardentHealAmount*paladin.MaxHealth(), spell.OutcomeHealingCrit) }, diff --git a/sim/common/itemhelpers/weaponprocs.go b/sim/common/itemhelpers/weaponprocs.go index 9b821c36c0..c0f1eba839 100644 --- a/sim/common/itemhelpers/weaponprocs.go +++ b/sim/common/itemhelpers/weaponprocs.go @@ -9,16 +9,22 @@ import ( // Create a simple weapon proc that deals damage. func CreateWeaponProcDamage(itemId int32, itemName string, ppm float64, spellId int32, school core.SpellSchool, dmgMin float64, dmgRange float64, bonusCoef float64, defType core.DefenseType) { + core.NewItemEffect(itemId, func(agent core.Agent) { character := agent.GetCharacter() + critMultiplier := character.DefaultSpellCritMultiplier() + if defType == core.DefenseTypeMelee || defType == core.DefenseTypeRanged { + critMultiplier = character.DefaultMeleeCritMultiplier() + } + sc := core.SpellConfig{ ActionID: core.ActionID{SpellID: spellId}, SpellSchool: school, ProcMask: core.ProcMaskEmpty, DamageMultiplier: 1, - CritMultiplier: character.DefaultSpellCritMultiplier(), + CritMultiplier: critMultiplier, ThreatMultiplier: 1, } diff --git a/sim/common/sod/crafted/phase_2.go b/sim/common/sod/crafted/phase_2.go index aa48db8314..d5813689c2 100644 --- a/sim/common/sod/crafted/phase_2.go +++ b/sim/common/sod/crafted/phase_2.go @@ -141,11 +141,9 @@ func init() { }, DamageMultiplier: 1, - CritMultiplier: 1, ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { - // TODO: Verify if this can crit - result := spell.CalcDamage(sim, &character.Unit, sim.Roll(343, 757), spell.OutcomeMagicCrit) + result := spell.CalcDamage(sim, &character.Unit, sim.Roll(343, 757), spell.OutcomeAlwaysHit) if sim.Log != nil { character.Log(sim, "Took %.1f damage from Gneuro-Logical Shock.", result.Damage) } @@ -264,11 +262,9 @@ func init() { }, DamageMultiplier: 1, - CritMultiplier: 1, ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { - // TODO: Verify if this can crit - result := spell.CalcDamage(sim, &character.Unit, sim.Roll(312, 668), spell.OutcomeMagicCrit) + result := spell.CalcDamage(sim, &character.Unit, sim.Roll(312, 668), spell.OutcomeAlwaysHit) character.RemoveHealth(sim, result.Damage) buffAura.Activate(sim) }, diff --git a/sim/common/sod/enchant_effects.go b/sim/common/sod/enchant_effects.go index 40158c1c9c..9ebce6252e 100644 --- a/sim/common/sod/enchant_effects.go +++ b/sim/common/sod/enchant_effects.go @@ -13,21 +13,18 @@ func init() { core.NewEnchantEffect(7210, func(agent core.Agent) { character := agent.GetCharacter() - procChance := 0.10 - baseDamageLow := 60.0 - baseDamageHigh := 90.0 - procSpell := character.GetOrRegisterSpell(core.SpellConfig{ ActionID: core.ActionID{SpellID: 439164}, SpellSchool: core.SpellSchoolNature, ProcMask: core.ProcMaskSpellDamage, + CritMultiplier: character.DefaultSpellCritMultiplier(), + DamageMultiplier: 1, - CritMultiplier: 1, ThreatMultiplier: 1, ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { - spell.CalcAndDealDamage(sim, target, sim.Roll(baseDamageLow, baseDamageHigh), spell.OutcomeMagicHitAndCrit) + spell.CalcAndDealDamage(sim, target, sim.Roll(60, 90), spell.OutcomeMagicHitAndCrit) }, }) @@ -74,7 +71,7 @@ func init() { } if spell.ProcMask.Matches(core.ProcMaskSpellDamage) { - if sim.RandomFloat("Dismantle") < procChance { + if sim.RandomFloat("Dismantle") < 0.10 { // Spells proc both Main-Hand and Off-Hand if both are enchanted if character.GetMHWeapon() != nil && character.GetMHWeapon().Enchant.EffectID == 7210 { procSpell.Cast(sim, result.Target) @@ -83,7 +80,7 @@ func init() { procSpell.Cast(sim, result.Target) } } - } else if sim.RandomFloat("Dismantle") < procChance { + } else if sim.RandomFloat("Dismantle") < 0.10 { // Physical hits only proc on the hand that was hit with procSpell.Cast(sim, result.Target) } diff --git a/sim/core/consumes.go b/sim/core/consumes.go index 8bb83afefa..a91ec63b27 100644 --- a/sim/core/consumes.go +++ b/sim/core/consumes.go @@ -101,7 +101,7 @@ func applyConsumeEffects(agent Agent, partyBuffs *proto.PartyBuffs) { } if consumes.DragonBreathChili { - MakePermanent(DragonBreathChiliAura(&character.Unit)) + MakePermanent(DragonBreathChiliAura(character)) } if consumes.AgilityElixir != proto.AgilityElixir_AgilityElixirUnknown { @@ -464,18 +464,19 @@ func registerExplosivesCD(agent Agent, consumes *proto.Consumes) { } } -func DragonBreathChiliAura(unit *Unit) *Aura { +func DragonBreathChiliAura(character *Character) *Aura { baseDamage := 60.0 procChance := .05 - procSpell := unit.RegisterSpell(SpellConfig{ + procSpell := character.RegisterSpell(SpellConfig{ ActionID: ActionID{SpellID: 15851}, SpellSchool: SpellSchoolFire, ProcMask: ProcMaskEmpty, Flags: SpellFlagNone, + CritMultiplier: character.DefaultSpellCritMultiplier(), + DamageMultiplier: 1, - CritMultiplier: 1, ThreatMultiplier: 1, ApplyEffects: func(sim *Simulation, target *Unit, spell *Spell) { @@ -483,7 +484,7 @@ func DragonBreathChiliAura(unit *Unit) *Aura { }, }) - aura := unit.GetOrRegisterAura(Aura{ + aura := character.GetOrRegisterAura(Aura{ Label: "Dragonbreath Chili", ActionID: ActionID{SpellID: 15852}, Duration: NeverExpires, @@ -529,9 +530,11 @@ func (character *Character) newBasicExplosiveSpellConfig(sharedTimer *Timer, act }, // Explosives always have 1% resist chance, so just give them hit cap. - BonusHitRating: 100 * SpellHitRatingPerHitChance, + BonusHitRating: 100 * SpellHitRatingPerHitChance, + + CritMultiplier: character.DefaultSpellCritMultiplier(), + DamageMultiplier: 1, - CritMultiplier: 2, ThreatMultiplier: 1, ApplyEffects: func(sim *Simulation, target *Unit, spell *Spell) { @@ -584,9 +587,11 @@ func (character *Character) newRadiationBombSpellConfig(sharedTimer *Timer, acti }, // Explosives always have 1% resist chance, so just give them hit cap. - BonusHitRating: 100 * SpellHitRatingPerHitChance, + BonusHitRating: 100 * SpellHitRatingPerHitChance, + + CritMultiplier: character.DefaultSpellCritMultiplier(), + DamageMultiplier: 1, - CritMultiplier: 2, ThreatMultiplier: 1, // TODO: This should use another spell (443813) as the DoT diff --git a/sim/encounters/naxxramas/patchwerk10_ai.go b/sim/encounters/naxxramas/patchwerk10_ai.go index e50eeaf780..84e424fdc1 100644 --- a/sim/encounters/naxxramas/patchwerk10_ai.go +++ b/sim/encounters/naxxramas/patchwerk10_ai.go @@ -79,8 +79,9 @@ func (ai *Patchwerk10AI) registerHatefulStrikeSpell(target *core.Target) { }, }, + CritMultiplier: 1, + DamageMultiplier: 1, - CritMultiplier: 1, ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { baseDamage := sim.Roll(27750, 32250) diff --git a/sim/encounters/naxxramas/patchwerk25_ai.go b/sim/encounters/naxxramas/patchwerk25_ai.go index 0b47b76b3f..a1fea835d8 100644 --- a/sim/encounters/naxxramas/patchwerk25_ai.go +++ b/sim/encounters/naxxramas/patchwerk25_ai.go @@ -80,8 +80,9 @@ func (ai *Patchwerk25AI) registerHatefulStrikeSpell(target *core.Target) { }, }, + CritMultiplier: 1, + DamageMultiplier: 1, - CritMultiplier: 1, ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { baseDamage := sim.Roll(79000, 81000) diff --git a/sim/hunter/raptor_strike.go b/sim/hunter/raptor_strike.go index 894bed9e15..9fe6514f8f 100644 --- a/sim/hunter/raptor_strike.go +++ b/sim/hunter/raptor_strike.go @@ -161,10 +161,8 @@ func (hunter *Hunter) makeQueueSpellsAndAura(srcSpell *core.Spell) *core.Spell { }) queueSpell := hunter.RegisterSpell(core.SpellConfig{ - ActionID: srcSpell.WithTag(1), - SpellSchool: core.SpellSchoolPhysical, - ProcMask: core.ProcMaskMeleeMHSpecial, - Flags: core.SpellFlagMeleeMetrics | core.SpellFlagAPL, + ActionID: srcSpell.WithTag(1), + Flags: core.SpellFlagMeleeMetrics | core.SpellFlagAPL, ExtraCastCondition: func(sim *core.Simulation, target *core.Unit) bool { return hunter.curQueueAura != queueAura && diff --git a/sim/hunter/serpent_sting.go b/sim/hunter/serpent_sting.go index 64b1ef6078..4ac8d8721d 100644 --- a/sim/hunter/serpent_sting.go +++ b/sim/hunter/serpent_sting.go @@ -68,7 +68,7 @@ func (hunter *Hunter) getSerpentStingConfig(rank int) core.SpellConfig { ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { // Reports of Bow of Searing Arrows proccing from SS applications means it has a hit event - result := spell.CalcDamage(sim, target, 0, spell.OutcomeRangedHit) + result := spell.CalcOutcome(sim, target, spell.OutcomeRangedHit) spell.WaitTravelTime(sim, func(s *core.Simulation) { spell.DealOutcome(sim, result) diff --git a/sim/priest/devouring_plague.go b/sim/priest/devouring_plague.go index 475c2997c8..ab8001efda 100644 --- a/sim/priest/devouring_plague.go +++ b/sim/priest/devouring_plague.go @@ -68,10 +68,9 @@ func (priest *Priest) getDevouringPlagueConfig(rank int, cdTimer *core.Timer) co }, }, - BonusHitRating: priest.shadowHitModifier(), - BonusCritRating: 0, + BonusHitRating: priest.shadowHitModifier(), + DamageMultiplier: 1, - CritMultiplier: 1, ThreatMultiplier: priest.shadowThreatModifier(), Dot: core.DotConfig{ diff --git a/sim/priest/mind_flay.go b/sim/priest/mind_flay.go index fa452e98f8..a3f53e853a 100644 --- a/sim/priest/mind_flay.go +++ b/sim/priest/mind_flay.go @@ -73,10 +73,9 @@ func (priest *Priest) newMindFlaySpellConfig(rank int, tickIdx int32) core.Spell }, }, - BonusHitRating: priest.shadowHitModifier(), - BonusCritRating: 0, + BonusHitRating: priest.shadowHitModifier(), + DamageMultiplier: 1, - CritMultiplier: 1, Dot: core.DotConfig{ Aura: core.Aura{ @@ -119,10 +118,9 @@ func (priest *Priest) newMindFlayTickSpell(rank int, numTicks int32) *core.Spell Rank: rank, - BonusHitRating: 1, // Not an independent hit once initial lands - BonusCritRating: 0, + BonusHitRating: 1, // Not an independent hit once initial lands + DamageMultiplier: priest.forceOfWillDamageModifier() * priest.darknessDamageModifier(), - CritMultiplier: 1.0, ThreatMultiplier: priest.shadowThreatModifier(), ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { diff --git a/sim/priest/mind_sear.go b/sim/priest/mind_sear.go index 289456171d..dad743275c 100644 --- a/sim/priest/mind_sear.go +++ b/sim/priest/mind_sear.go @@ -53,10 +53,9 @@ func (priest *Priest) newMindSearSpellConfig(tickIdx int32) core.SpellConfig { }, }, - BonusHitRating: priest.shadowHitModifier(), - BonusCritRating: 0, + BonusHitRating: priest.shadowHitModifier(), + DamageMultiplier: 1, - CritMultiplier: 1, Dot: core.DotConfig{ IsAOE: true, @@ -89,7 +88,7 @@ func (priest *Priest) newMindSearSpellConfig(tickIdx int32) core.SpellConfig { func (priest *Priest) newMindSearTickSpell(numTicks int32) *core.Spell { level := float64(priest.Level) - baseDamage := (9.456667 + 0.635108*level + 0.039063*level*level) + baseDamage := 9.456667 + 0.635108*level + 0.039063*level*level baseDamageLow := baseDamage * .7 * priest.darknessDamageModifier() baseDamageHigh := baseDamage * .78 * priest.darknessDamageModifier() spellCoeff := 0.15 // classic penalty for mf having a slow effect @@ -99,15 +98,17 @@ func (priest *Priest) newMindSearTickSpell(numTicks int32) *core.Spell { SpellSchool: core.SpellSchoolShadow, ProcMask: core.ProcMaskProc | core.ProcMaskNotInSpellbook, - BonusHitRating: 1, // Not an independent hit once initial lands - BonusCritRating: priest.forceOfWillCritRating(), + BonusHitRating: 1, // Not an independent hit once initial lands + BonusCritRating: priest.forceOfWillCritRating(), + + CritMultiplier: priest.DefaultSpellCritMultiplier(), + DamageMultiplier: priest.forceOfWillDamageModifier(), - CritMultiplier: 1, ThreatMultiplier: priest.shadowThreatModifier(), ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { damage := sim.Roll(baseDamageLow, baseDamageHigh) + (spellCoeff * spell.SpellDamage()) - result := spell.CalcAndDealDamage(sim, target, damage, spell.OutcomeMagicHit) + result := spell.CalcAndDealDamage(sim, target, damage, spell.OutcomeMagicHitAndCrit) if result.Landed() { priest.AddShadowWeavingStack(sim, target) diff --git a/sim/priest/shadow_word_death.go b/sim/priest/shadow_word_death.go index 0e3daaf935..4a9ac8d897 100644 --- a/sim/priest/shadow_word_death.go +++ b/sim/priest/shadow_word_death.go @@ -40,10 +40,12 @@ func (priest *Priest) registerShadowWordDeathSpell() { }, }, - BonusHitRating: priest.shadowHitModifier(), - BonusCritRating: priest.forceOfWillCritRating(), + BonusHitRating: priest.shadowHitModifier(), + BonusCritRating: priest.forceOfWillCritRating(), + + CritMultiplier: priest.DefaultSpellCritMultiplier(), + DamageMultiplier: priest.forceOfWillDamageModifier(), - CritMultiplier: 1, ThreatMultiplier: priest.shadowThreatModifier(), ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { diff --git a/sim/priest/shadow_word_pain.go b/sim/priest/shadow_word_pain.go index e02b776b72..8133f3f2e4 100644 --- a/sim/priest/shadow_word_pain.go +++ b/sim/priest/shadow_word_pain.go @@ -58,9 +58,8 @@ func (priest *Priest) getShadowWordPainConfig(rank int) core.SpellConfig { }, BonusHitRating: priest.shadowHitModifier(), - BonusCritRating: 0, DamageMultiplier: priest.forceOfWillDamageModifier() * priest.darknessDamageModifier(), - CritMultiplier: 1, + ThreatMultiplier: priest.shadowThreatModifier(), Dot: core.DotConfig{ diff --git a/sim/priest/void_plague.go b/sim/priest/void_plague.go index 971aa503e1..1fcf02d053 100644 --- a/sim/priest/void_plague.go +++ b/sim/priest/void_plague.go @@ -40,10 +40,9 @@ func (priest *Priest) getVoidPlagueConfig() core.SpellConfig { }, }, - BonusHitRating: priest.shadowHitModifier(), - BonusCritRating: priest.forceOfWillCritRating(), + BonusHitRating: priest.shadowHitModifier(), + DamageMultiplier: priest.forceOfWillDamageModifier() * priest.darknessDamageModifier(), - CritMultiplier: 1, ThreatMultiplier: priest.shadowThreatModifier(), Dot: core.DotConfig{ diff --git a/sim/rogue/envenom.go b/sim/rogue/envenom.go index 4a031837bc..721aad0216 100644 --- a/sim/rogue/envenom.go +++ b/sim/rogue/envenom.go @@ -49,8 +49,9 @@ func (rogue *Rogue) registerEnvenom() { return rogue.ComboPoints() > 0 && target.GetAuraByID(rogue.DeadlyPoison[0].ActionID).IsActive() }, + CritMultiplier: rogue.MeleeCritMultiplier(false), + DamageMultiplier: rogue.getPoisonDamageMultiplier(), - CritMultiplier: rogue.MeleeCritMultiplier(true), ThreatMultiplier: 1, ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { diff --git a/sim/rogue/shuriken_toss.go b/sim/rogue/shuriken_toss.go index 5e01a0eff3..640a678c8e 100644 --- a/sim/rogue/shuriken_toss.go +++ b/sim/rogue/shuriken_toss.go @@ -34,8 +34,9 @@ func (rogue *Rogue) registerShurikenTossSpell() { IgnoreHaste: true, }, + CritMultiplier: rogue.RangedCritMultiplier(false), + DamageMultiplier: 1, - CritMultiplier: rogue.RangedCritMultiplier(true), ThreatMultiplier: 1, ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { diff --git a/sim/shaman/ancestral_awakening.go b/sim/shaman/ancestral_awakening.go index 62ec89b5cb..c9d6f779d2 100644 --- a/sim/shaman/ancestral_awakening.go +++ b/sim/shaman/ancestral_awakening.go @@ -13,13 +13,16 @@ func (shaman *Shaman) applyAncestralAwakening() { } shaman.AncestralAwakening = shaman.RegisterSpell(core.SpellConfig{ - ActionID: core.ActionID{SpellID: int32(proto.ShamanRune_RuneFeetAncestralAwakening)}, - SpellSchool: core.SpellSchoolNature, - ProcMask: core.ProcMaskSpellHealing, - Flags: core.SpellFlagHelpful | core.SpellFlagAPL, + ActionID: core.ActionID{SpellID: int32(proto.ShamanRune_RuneFeetAncestralAwakening)}, + SpellSchool: core.SpellSchoolNature, + ProcMask: core.ProcMaskSpellHealing, + Flags: core.SpellFlagHelpful | core.SpellFlagAPL, + + CritMultiplier: 1, + DamageMultiplier: 1 * (1 + .02*float64(shaman.Talents.Purification)), - CritMultiplier: 1, ThreatMultiplier: 1, + ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { spell.CalcAndDealHealing(sim, target, shaman.ancestralHealingAmount, spell.OutcomeHealing) }, diff --git a/sim/shaman/ancestral_guidance.go b/sim/shaman/ancestral_guidance.go index 62d915738f..2c613f3c5d 100644 --- a/sim/shaman/ancestral_guidance.go +++ b/sim/shaman/ancestral_guidance.go @@ -26,8 +26,9 @@ func (shaman *Shaman) applyAncestralGuidance() { ProcMask: core.ProcMaskSpellDamage, Flags: core.SpellFlagIgnoreResists, + CritMultiplier: 1, + DamageMultiplier: 1, - CritMultiplier: 1, ThreatMultiplier: 1, }) diff --git a/sim/shaman/water_totems.go b/sim/shaman/water_totems.go index 0581e2568c..bdfc891f58 100644 --- a/sim/shaman/water_totems.go +++ b/sim/shaman/water_totems.go @@ -49,8 +49,9 @@ func (shaman *Shaman) newHealingStreamTotemSpellConfig(rank int) core.SpellConfi ProcMask: core.ProcMaskSpellHealing, Flags: core.SpellFlagHelpful | core.SpellFlagNoOnCastComplete | core.SpellFlagNoLogs | core.SpellFlagNoMetrics, + CritMultiplier: 1, + DamageMultiplier: 1 + (.02 * float64(shaman.Talents.Purification)) + 0.05*float64(shaman.Talents.RestorativeTotems), - CritMultiplier: 1, ThreatMultiplier: 1 - (float64(shaman.Talents.HealingGrace) * 0.05), ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) { diff --git a/sim/warlock/corruption.go b/sim/warlock/corruption.go index 369513135e..b9685e64b0 100644 --- a/sim/warlock/corruption.go +++ b/sim/warlock/corruption.go @@ -37,11 +37,10 @@ func (warlock *Warlock) getCorruptionConfig(rank int) core.SpellConfig { }, }, - BonusHitRating: float64(warlock.Talents.Suppression) * 2 * core.SpellHitRatingPerHitChance, - BonusCritRating: 0, + BonusHitRating: float64(warlock.Talents.Suppression) * 2 * core.SpellHitRatingPerHitChance, + DamageMultiplierAdditive: 1 + 0.02*float64(warlock.Talents.ShadowMastery), DamageMultiplier: 1, - CritMultiplier: 1, ThreatMultiplier: 1, Dot: core.DotConfig{ diff --git a/sim/warrior/heroic_strike_cleave.go b/sim/warrior/heroic_strike_cleave.go index 94888a0571..8576f2edc0 100644 --- a/sim/warrior/heroic_strike_cleave.go +++ b/sim/warrior/heroic_strike_cleave.go @@ -134,10 +134,8 @@ func (warrior *Warrior) makeQueueSpellsAndAura(srcSpell *core.Spell) *core.Spell }) queueSpell := warrior.RegisterSpell(core.SpellConfig{ - ActionID: srcSpell.WithTag(1), - SpellSchool: core.SpellSchoolPhysical, - ProcMask: core.ProcMaskMeleeMHSpecial, - Flags: core.SpellFlagMeleeMetrics | core.SpellFlagAPL, + ActionID: srcSpell.WithTag(1), + Flags: core.SpellFlagMeleeMetrics | core.SpellFlagAPL, ExtraCastCondition: func(sim *core.Simulation, target *core.Unit) bool { return warrior.curQueueAura != queueAura && diff --git a/sim/warrior/items.go b/sim/warrior/items.go index f499ec11a1..d64a07445c 100644 --- a/sim/warrior/items.go +++ b/sim/warrior/items.go @@ -29,7 +29,6 @@ func init() { }, DamageMultiplier: 1, - CritMultiplier: 1, Dot: core.DotConfig{ Aura: core.Aura{ @@ -41,7 +40,6 @@ func init() { OnSnapshot: func(sim *core.Simulation, target *core.Unit, dot *core.Dot, isRollover bool) { dot.SnapshotBaseDamage = 5 * character.PseudoStats.SchoolDamageDealtMultiplier[stats.SchoolIndexPhysical] attackTable := dot.Spell.Unit.AttackTables[target.UnitIndex][dot.Spell.CastType] - dot.SnapshotCritChance = 0 dot.SnapshotAttackerMultiplier = dot.Spell.AttackerDamageMultiplier(attackTable) },