Merge pull request #1290 from wowsims/feature/spell-mod-additions

Additional Spell Mods

sim/core/aura.go

@@ -898,6 +898,26 @@ func (auras AuraArray) Get(target *Unit) *Aura {
 	return auras[target.UnitIndex]
 }
 
+func (auras AuraArray) IsEmpty() bool {
+	for _, aura := range auras {
+		if aura != nil {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (auras AuraArray) FindLabel() string {
+	for _, aura := range auras {
+		if aura != nil {
+			return aura.Label
+		}
+	}
+
+	panic("No valid auras in array!")
+}
+
 func (caster *Unit) NewAllyAuraArray(makeAura func(*Unit) *Aura) AuraArray {
 	auras := make([]*Aura, len(caster.Env.AllUnits))
 	for _, target := range caster.Env.AllUnits {
@@ -917,3 +937,36 @@ func (caster *Unit) NewEnemyAuraArray(makeAura func(*Unit) *Aura) AuraArray {
 	}
 	return auras
 }
+
+type LabeledAuraArrays map[string]AuraArray
+
+func (auras AuraArray) ToMap() LabeledAuraArrays {
+	if auras.IsEmpty() {
+		return nil
+	} else {
+		return LabeledAuraArrays{auras.FindLabel(): auras}
+	}
+}
+
+func (auraArrays LabeledAuraArrays) AnyActive(target *Unit) bool {
+	for _, auras := range auraArrays {
+		if auras.Get(target).IsActive() {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (auraArrays LabeledAuraArrays) Append(auras AuraArray) LabeledAuraArrays {
+	if auras.IsEmpty() {
+		return auraArrays
+	}
+
+	if auraArrays == nil {
+		auraArrays = make(LabeledAuraArrays)
+	}
+
+	auraArrays[auras.FindLabel()] = auras
+	return auraArrays
+}

sim/core/exclusive_effect.go

@@ -222,7 +222,7 @@ func (aura *Aura) ShouldRefreshExclusiveEffects(sim *Simulation, refreshWindow t
 	return false
 }
 func (spell *Spell) ShouldRefreshExclusiveEffects(sim *Simulation, target *Unit, refreshWindow time.Duration) bool {
-	for _, auraArray := range spell.RelatedAuras {
+	for _, auraArray := range spell.RelatedAuraArrays {
 		aura := auraArray.Get(target)
 		if aura != nil && aura.ShouldRefreshExclusiveEffects(sim, refreshWindow) {
 			return true

sim/core/spell.go

@@ -63,8 +63,9 @@ type SpellConfig struct {
 	Hot    DotConfig
 	Shield ShieldConfig
 
-	RelatedAuras    []AuraArray
-	RelatedDotSpell *Spell
+	RelatedAuraArrays LabeledAuraArrays
+	RelatedDotSpell   *Spell
+	RelatedSelfBuff   *Aura
 }
 
 type Spell struct {
@@ -153,8 +154,9 @@ type Spell struct {
 	selfShield *Shield
 
 	// Per-target auras that are related to this spell, usually buffs or debuffs applied by the spell.
-	RelatedAuras    []AuraArray
-	RelatedDotSpell *Spell
+	RelatedAuraArrays LabeledAuraArrays
+	RelatedDotSpell   *Spell
+	RelatedSelfBuff   *Aura
 }
 
 func (unit *Unit) OnSpellRegistered(handler SpellRegisteredHandler) {
@@ -239,8 +241,9 @@ func (unit *Unit) RegisterSpell(config SpellConfig) *Spell {
 
 		splitSpellMetrics: make([][]SpellMetrics, max(1, config.MetricSplits)),
 
-		RelatedAuras:    config.RelatedAuras,
-		RelatedDotSpell: config.RelatedDotSpell,
+		RelatedAuraArrays: config.RelatedAuraArrays,
+		RelatedDotSpell:   config.RelatedDotSpell,
+		RelatedSelfBuff:   config.RelatedSelfBuff,
 	}
 
 	switch {

sim/core/spell_mod.go

@@ -10,13 +10,16 @@ SpellMod implementation.
 */
 
 type SpellModConfig struct {
-	ClassMask  int64
-	Kind       SpellModType
-	School     SpellSchool
-	ProcMask   ProcMask
-	IntValue   int64
-	TimeValue  time.Duration
-	FloatValue float64
+	ClassMask    int64
+	Kind         SpellModType
+	School       SpellSchool
+	ProcMask     ProcMask
+	IntValue     int64
+	TimeValue    time.Duration
+	FloatValue   float64
+	KeyValue     string
+	ApplyCustom  SpellModApply
+	RemoveCustom SpellModRemove
 }
 
 type SpellMod struct {
@@ -27,6 +30,7 @@ type SpellMod struct {
 	floatValue     float64
 	intValue       int64
 	timeValue      time.Duration
+	keyValue       string
 	Apply          SpellModApply
 	Remove         SpellModRemove
 	IsActive       bool
@@ -46,6 +50,21 @@ func buildMod(unit *Unit, config SpellModConfig) *SpellMod {
 		panic("SpellMod " + strconv.Itoa(int(config.Kind)) + " not implmented")
 	}
 
+	var applyFn SpellModApply
+	var removeFn SpellModRemove
+
+	if config.Kind == SpellMod_Custom {
+		if (config.ApplyCustom == nil) || (config.RemoveCustom == nil) {
+			panic("ApplyCustom and RemoveCustom are mandatory fields for SpellMod_Custom")
+		}
+
+		applyFn = config.ApplyCustom
+		removeFn = config.RemoveCustom
+	} else {
+		applyFn = functions.Apply
+		removeFn = functions.Remove
+	}
+
 	mod := &SpellMod{
 		ClassMask:  config.ClassMask,
 		Kind:       config.Kind,
@@ -54,8 +73,9 @@ func buildMod(unit *Unit, config SpellModConfig) *SpellMod {
 		floatValue: config.FloatValue,
 		intValue:   config.IntValue,
 		timeValue:  config.TimeValue,
-		Apply:      functions.Apply,
-		Remove:     functions.Remove,
+		keyValue:   config.KeyValue,
+		Apply:      applyFn,
+		Remove:     removeFn,
 		IsActive:   false,
 	}
 
@@ -245,6 +265,18 @@ const (
 	// Add/subtract bonus expertise rating
 	// Uses: FloatValue
 	SpellMod_BonusExpertise_Rating
+
+	// Add/subtract duration for associated debuff
+	// Uses: KeyValue, TimeValue
+	SpellMod_DebuffDuration_Flat
+
+	// Add/subtract duration for associated self-buff
+	// Uses: TimeValue
+	SpellMod_BuffDuration_Flat
+
+	// User-defined implementation
+	// Uses: ApplyCustom | RemoveCustom
+	SpellMod_Custom
 )
 
 var spellModMap = map[SpellModType]*SpellModFunctions{
@@ -341,6 +373,20 @@ var spellModMap = map[SpellModType]*SpellModFunctions{
 		Apply:  applyBonusExpertiseRating,
 		Remove: removeBonusExpertiseRating,
 	},
+
+	SpellMod_DebuffDuration_Flat: {
+		Apply:  applyDebuffDurationFlat,
+		Remove: removeDebuffDurationFlat,
+	},
+
+	SpellMod_BuffDuration_Flat: {
+		Apply:  applyBuffDurationFlat,
+		Remove: removeBuffDurationFlat,
+	},
+
+	SpellMod_Custom: {
+		// Doesn't have dedicated Apply/Remove functions as ApplyCustom/RemoveCustom is handled in buildMod()
+	},
 }
 
 func applyDamageDonePercent(mod *SpellMod, spell *Spell) {
@@ -534,3 +580,39 @@ func applyBonusExpertiseRating(mod *SpellMod, spell *Spell) {
 func removeBonusExpertiseRating(mod *SpellMod, spell *Spell) {
 	spell.BonusExpertiseRating -= mod.floatValue
 }
+
+func applyDebuffDurationFlat(mod *SpellMod, spell *Spell) {
+	debuffAuraArray := spell.RelatedAuraArrays[mod.keyValue]
+
+	if debuffAuraArray == nil {
+		panic("No debuff found for key: " + mod.keyValue)
+	}
+
+	for _, debuffAura := range debuffAuraArray {
+		if debuffAura != nil {
+			debuffAura.Duration += mod.timeValue
+		}
+	}
+}
+
+func removeDebuffDurationFlat(mod *SpellMod, spell *Spell) {
+	debuffAuraArray := spell.RelatedAuraArrays[mod.keyValue]
+
+	if debuffAuraArray == nil {
+		panic("No debuff found for key: " + mod.keyValue)
+	}
+
+	for _, debuffAura := range debuffAuraArray {
+		if debuffAura != nil {
+			debuffAura.Duration -= mod.timeValue
+		}
+	}
+}
+
+func applyBuffDurationFlat(mod *SpellMod, spell *Spell) {
+	spell.RelatedSelfBuff.Duration += mod.timeValue
+}
+
+func removeBuffDurationFlat(mod *SpellMod, spell *Spell) {
+	spell.RelatedSelfBuff.Duration -= mod.timeValue
+}

sim/death_knight/diseases.go

@@ -97,7 +97,7 @@ func (dk *DeathKnight) registerFrostFever() {
 			spell.Dot(target).Apply(sim)
 		},
 
-		RelatedAuras: []core.AuraArray{extraEffectAura},
+		RelatedAuraArrays: extraEffectAura.ToMap(),
 	})
 }
 

sim/death_knight/talents_blood.go

@@ -156,7 +156,7 @@ func (dk *DeathKnight) applyScarletFever() {
 		return core.ScarletFeverAura(target, dk.Talents.ScarletFever, dk.Talents.Epidemic)
 	})
 	dk.Env.RegisterPreFinalizeEffect(func() {
-		dk.BloodPlagueSpell.RelatedAuras = append(dk.BloodPlagueSpell.RelatedAuras, dk.ScarletFeverAura)
+		dk.BloodPlagueSpell.RelatedAuraArrays = dk.BloodPlagueSpell.RelatedAuraArrays.Append(dk.ScarletFeverAura)
 	})
 
 	core.MakeProcTriggerAura(&dk.Unit, core.ProcTrigger{

sim/death_knight/talents_unholy.go

@@ -244,8 +244,8 @@ func (dk *DeathKnight) applyEbonPlaguebringer() {
 		return aura
 	})
 	dk.Env.RegisterPreFinalizeEffect(func() {
-		dk.FrostFeverSpell.RelatedAuras = append(dk.FrostFeverSpell.RelatedAuras, dk.EbonPlagueAura)
-		dk.BloodPlagueSpell.RelatedAuras = append(dk.BloodPlagueSpell.RelatedAuras, dk.EbonPlagueAura)
+		dk.FrostFeverSpell.RelatedAuraArrays = dk.FrostFeverSpell.RelatedAuraArrays.Append(dk.EbonPlagueAura)
+		dk.BloodPlagueSpell.RelatedAuraArrays = dk.BloodPlagueSpell.RelatedAuraArrays.Append(dk.EbonPlagueAura)
 	})
 
 	var lastDiseaseTarget *core.Unit = nil

sim/druid/demoralizing_roar.go

@@ -37,6 +37,6 @@ func (druid *Druid) registerDemoralizingRoarSpell() {
 			}
 		},
 
-		RelatedAuras: []core.AuraArray{druid.DemoralizingRoarAuras},
+		RelatedAuraArrays: druid.DemoralizingRoarAuras.ToMap(),
 	})
 }

sim/druid/faerie_fire.go

@@ -70,7 +70,7 @@ func (druid *Druid) registerFaerieFireSpell() {
 			}
 		},
 
-		RelatedAuras: []core.AuraArray{druid.FaerieFireAuras},
+		RelatedAuraArrays: druid.FaerieFireAuras.ToMap(),
 	})
 }
 

sim/druid/mangle.go

@@ -69,7 +69,7 @@ func (druid *Druid) registerMangleBearSpell() {
 			}
 		},
 
-		RelatedAuras: []core.AuraArray{mangleAuras},
+		RelatedAuraArrays: mangleAuras.ToMap(),
 	})
 }
 
@@ -139,7 +139,7 @@ func (druid *Druid) registerMangleCatSpell() {
 			return spell.CalcDamage(sim, target, baseDamage, spell.OutcomeExpectedMeleeWeaponSpecialHitAndCrit)
 		},
 
-		RelatedAuras: []core.AuraArray{mangleAuras},
+		RelatedAuraArrays: mangleAuras.ToMap(),
 	})
 }
 

sim/druid/talents.go

@@ -868,7 +868,7 @@ func (druid *Druid) applyInfectedWounds() {
 
 		for _, spell := range triggeringSpells {
 			if spell != nil {
-				spell.RelatedAuras = append(spell.RelatedAuras, iwAuras)
+				spell.RelatedAuraArrays = spell.RelatedAuraArrays.Append(iwAuras)
 			}
 		}
 	})

sim/hunter/pet_abilities.go

@@ -148,7 +148,7 @@ func (hp *HunterPet) newPetDebuff(config PetDebuffSpellConfig) *core.Spell {
 			spell.DealOutcome(sim, result)
 		},
 
-		RelatedAuras: []core.AuraArray{auraArray},
+		RelatedAuraArrays: auraArray.ToMap(),
 	})
 }
 

sim/rogue/expose_armor.go

@@ -70,6 +70,6 @@ func (rogue *Rogue) registerExposeArmorSpell() {
 			spell.DealOutcome(sim, result)
 		},
 
-		RelatedAuras: []core.AuraArray{rogue.ExposeArmorAuras},
+		RelatedAuraArrays: rogue.ExposeArmorAuras.ToMap(),
 	})
 }

sim/rogue/subtlety/hemorrhage.go

@@ -97,7 +97,7 @@ func (subRogue *SubtletyRogue) registerHemorrhageSpell() {
 			}
 		},
 
-		RelatedAuras: []core.AuraArray{hemoAuras},
+		RelatedAuraArrays: hemoAuras.ToMap(),
 	})
 
 	subRogue.RegisterOnItemSwap(func(s *core.Simulation) {

sim/rogue/subtlety/sanguinary_vein.go

@@ -45,10 +45,10 @@ func (subRogue *SubtletyRogue) registerSanguinaryVein() {
 
 	subRogue.Env.RegisterPreFinalizeEffect(func() {
 		if subRogue.Rupture != nil {
-			subRogue.Rupture.RelatedAuras = append(subRogue.Rupture.RelatedAuras, svDebuffArray)
+			subRogue.Rupture.RelatedAuraArrays = subRogue.Rupture.RelatedAuraArrays.Append(svDebuffArray)
 		}
 		if subRogue.Hemorrhage != nil && hasGlyph {
-			subRogue.Hemorrhage.RelatedAuras = append(subRogue.Hemorrhage.RelatedAuras, svDebuffArray)
+			subRogue.Hemorrhage.RelatedAuraArrays = subRogue.Hemorrhage.RelatedAuraArrays.Append(svDebuffArray)
 		}
 	})
 

sim/warlock/affliction/haunt.go

@@ -65,6 +65,7 @@ func (affliction *AfflictionWarlock) registerHaunt() {
 				}
 			})
 		},
-		RelatedAuras: []core.AuraArray{affliction.HauntDebuffAuras},
+
+		RelatedAuraArrays: affliction.HauntDebuffAuras.ToMap(),
 	})
 }