Merge pull request wowsims#3810 from wowsims/apl

Refactor expected damage functions to split initial and tick calcs
lime-green · Oct 4, 2023 · ec3bf25 · ec3bf25
2 parents 17943a4 + 2b93fc0
commit ec3bf25
Show file tree

Hide file tree

Showing 16 changed files with 54 additions and 486 deletions.
diff --git a/sim/core/spell.go b/sim/core/spell.go
@@ -48,7 +48,8 @@ type SpellConfig struct {
 	ApplyEffects ApplySpellResults
 
 	// Optional field. Calculates expected average damage.
-	ExpectedDamage ExpectedDamageCalculator
+	ExpectedInitialDamage ExpectedDamageCalculator
+	ExpectedTickDamage    ExpectedDamageCalculator
 
 	Dot    DotConfig
 	Hot    DotConfig
@@ -98,7 +99,8 @@ type Spell struct {
 	ApplyEffects ApplySpellResults
 
 	// Optional field. Calculates expected average damage.
-	expectedDamageInternal ExpectedDamageCalculator
+	expectedInitialDamageInternal ExpectedDamageCalculator
+	expectedTickDamageInternal    ExpectedDamageCalculator
 
 	// The current or most recent cast data.
 	CurCast Cast
@@ -197,7 +199,8 @@ func (unit *Unit) RegisterSpell(config SpellConfig) *Spell {
 
 		ApplyEffects: config.ApplyEffects,
 
-		expectedDamageInternal: config.ExpectedDamage,
+		expectedInitialDamageInternal: config.ExpectedInitialDamage,
+		expectedTickDamageInternal:    config.ExpectedTickDamage,
 
 		BonusHitRating:           config.BonusHitRating,
 		BonusCritRating:          config.BonusCritRating,
@@ -535,21 +538,28 @@ func (spell *Spell) ApplyAOEThreat(threatAmount float64) {
 	spell.ApplyAOEThreatIgnoreMultipliers(threatAmount * spell.Unit.PseudoStats.ThreatMultiplier)
 }
 
-func (spell *Spell) expectedDamageHelper(sim *Simulation, target *Unit, useSnapshot bool) float64 {
-	result := spell.expectedDamageInternal(sim, target, spell, useSnapshot)
+func (spell *Spell) finalizeExpectedDamage(result *SpellResult) {
 	if !spell.SpellSchool.Matches(SpellSchoolPhysical) {
 		result.Damage /= result.ResistanceMultiplier
 		result.Damage *= AverageMagicPartialResistMultiplier
 		result.ResistanceMultiplier = AverageMagicPartialResistMultiplier
 	}
 	result.inUse = false
+}
+func (spell *Spell) ExpectedInitialDamage(sim *Simulation, target *Unit) float64 {
+	result := spell.expectedInitialDamageInternal(sim, target, spell, false)
+	spell.finalizeExpectedDamage(result)
 	return result.Damage
 }
-func (spell *Spell) ExpectedDamage(sim *Simulation, target *Unit) float64 {
-	return spell.expectedDamageHelper(sim, target, false)
+func (spell *Spell) ExpectedTickDamage(sim *Simulation, target *Unit) float64 {
+	result := spell.expectedTickDamageInternal(sim, target, spell, false)
+	spell.finalizeExpectedDamage(result)
+	return result.Damage
 }
-func (spell *Spell) ExpectedDamageFromCurrentSnapshot(sim *Simulation, target *Unit) float64 {
-	return spell.expectedDamageHelper(sim, target, true)
+func (spell *Spell) ExpectedTickDamageFromCurrentSnapshot(sim *Simulation, target *Unit) float64 {
+	result := spell.expectedTickDamageInternal(sim, target, spell, true)
+	spell.finalizeExpectedDamage(result)
+	return result.Damage
 }
 
 // Time until either the cast is finished or GCD is ready again, whichever is longer

diff --git a/sim/druid/feral/rotation.go b/sim/druid/feral/rotation.go
@@ -215,8 +215,9 @@ func (cat *FeralDruid) calcBuilderDpe(sim *core.Simulation) (float64, float64) {
 	// Calculate current damage-per-Energy of Rake vs. Shred. Used to
 	// determine whether Rake is worth casting when player stats change upon a
 	// dynamic proc occurring
-	shredDpc := cat.Shred.ExpectedDamage(sim, cat.CurrentTarget)
-	rakeDpc := cat.Rake.ExpectedDamage(sim, cat.CurrentTarget)
+	shredDpc := cat.Shred.ExpectedInitialDamage(sim, cat.CurrentTarget)
+	potentialRakeTicks := min(cat.Rake.CurDot().NumberOfTicks, int32(sim.GetRemainingDuration()/time.Second*3))
+	rakeDpc := cat.Rake.ExpectedInitialDamage(sim, cat.CurrentTarget) + cat.Rake.ExpectedTickDamage(sim, cat.CurrentTarget)*float64(potentialRakeTicks)
 	return rakeDpc / cat.Rake.DefaultCast.Cost, shredDpc / cat.Shred.DefaultCast.Cost
 }
 

diff --git a/sim/druid/rake.go b/sim/druid/rake.go
@@ -7,7 +7,6 @@ import (
 )
 
 func (druid *Druid) registerRakeSpell() {
-	numTicks := 3 + core.TernaryInt32(druid.HasSetBonus(ItemSetMalfurionsBattlegear, 2), 1, 0)
 	dotCanCrit := druid.HasSetBonus(ItemSetLasherweaveBattlegear, 4)
 
 	druid.Rake = druid.RegisterSpell(Cat, core.SpellConfig{
@@ -36,7 +35,7 @@ func (druid *Druid) registerRakeSpell() {
 				Label:    "Rake",
 				Duration: time.Second * 9,
 			}),
-			NumberOfTicks: numTicks,
+			NumberOfTicks: 3 + core.TernaryInt32(druid.HasSetBonus(ItemSetMalfurionsBattlegear, 2), 1, 0),
 			TickLength:    time.Second * 3,
 			OnSnapshot: func(sim *core.Simulation, target *core.Unit, dot *core.Dot, isRollover bool) {
 				dot.SnapshotBaseDamage = 358 + 0.06*dot.Spell.MeleeAttackPower()
@@ -69,12 +68,18 @@ func (druid *Druid) registerRakeSpell() {
 			}
 		},
 
-		ExpectedDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
+		ExpectedInitialDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
 			baseDamage := 176 + 0.01*spell.MeleeAttackPower()
-			potentialTicks := min(numTicks, int32(sim.GetRemainingDuration()/time.Second*3))
-			tickBase := (358 + 0.06*spell.MeleeAttackPower()) * float64(potentialTicks)
-
 			initial := spell.CalcPeriodicDamage(sim, target, baseDamage, spell.OutcomeExpectedMagicAlwaysHit)
+
+			attackTable := spell.Unit.AttackTables[target.UnitIndex]
+			critChance := spell.PhysicalCritChance(attackTable)
+			critMod := (critChance * (spell.CritMultiplier - 1))
+			initial.Damage *= 1 + critMod
+			return initial
+		},
+		ExpectedTickDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
+			tickBase := (358 + 0.06*spell.MeleeAttackPower())
 			ticks := spell.CalcPeriodicDamage(sim, target, tickBase, spell.OutcomeExpectedMagicAlwaysHit)
 
 			attackTable := spell.Unit.AttackTables[target.UnitIndex]
@@ -85,7 +90,6 @@ func (druid *Druid) registerRakeSpell() {
 				ticks.Damage *= 1 + critMod
 			}
 
-			ticks.Damage += initial.Damage * (1 + critMod)
 			return ticks
 		},
 	})

diff --git a/sim/druid/shred.go b/sim/druid/shred.go
@@ -71,7 +71,7 @@ func (druid *Druid) registerShredSpell() {
 				spell.IssueRefund(sim)
 			}
 		},
-		ExpectedDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
+		ExpectedInitialDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
 			baseDamage := flatDamageBonus + spell.Unit.AutoAttacks.MH.CalculateAverageWeaponDamage(spell.MeleeAttackPower()) + spell.BonusWeaponDamage()
 
 			modifier := 1.0

diff --git a/sim/priest/devouring_plague.go b/sim/priest/devouring_plague.go
@@ -110,7 +110,7 @@ func (priest *Priest) registerDevouringPlagueSpell() {
 				spell.Dot(target).Apply(sim)
 			}
 		},
-		ExpectedDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, useSnapshot bool) *core.SpellResult {
+		ExpectedTickDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, useSnapshot bool) *core.SpellResult {
 			if useSnapshot {
 				dot := spell.Dot(target)
 				if priest.Talents.Shadowform {

diff --git a/sim/priest/mind_blast.go b/sim/priest/mind_blast.go
@@ -84,7 +84,7 @@ func (priest *Priest) registerMindBlastSpell() {
 				}
 			}
 		},
-		ExpectedDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
+		ExpectedInitialDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
 			baseDamage := (997.0+1053.0)/2 + spellCoeff*spell.SpellPower()
 			return spell.CalcDamage(sim, target, baseDamage, spell.OutcomeExpectedMagicHitAndCrit)
 		},

diff --git a/sim/priest/mind_flay.go b/sim/priest/mind_flay.go
@@ -146,9 +146,8 @@ func (priest *Priest) newMindFlaySpell(numTicksIdx int32) *core.Spell {
 			}
 			spell.DealOutcome(sim, result)
 		},
-		ExpectedDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
+		ExpectedTickDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
 			baseDamage := 588.0/3 + miseryCoeff*spell.SpellPower()
-			baseDamage *= float64(numTicks)
 
 			if priest.Talents.Shadowform {
 				return spell.CalcPeriodicDamage(sim, target, baseDamage, spell.OutcomeExpectedMagicCrit)

diff --git a/sim/priest/mind_sear.go b/sim/priest/mind_sear.go
@@ -85,9 +85,8 @@ func (priest *Priest) newMindSearSpell(numTicksIdx int32) *core.Spell {
 				}
 			}
 		},
-		ExpectedDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
+		ExpectedTickDamage: func(sim *core.Simulation, target *core.Unit, spell *core.Spell, _ bool) *core.SpellResult {
 			baseDamage := sim.Roll(212, 228) + miseryCoeff*spell.SpellPower()
-			baseDamage *= float64(numTicks)
 			return spell.CalcPeriodicDamage(sim, target, baseDamage, spell.OutcomeExpectedMagicCrit)
 		},
 	})