shaman

Documentation

Index

• Constants
• Variables
• type APLValueTotemRemainingTime
  • func (value *APLValueTotemRemainingTime) GetDuration(sim *core.Simulation) time.Duration
  • func (value *APLValueTotemRemainingTime) String() string
  • func (value *APLValueTotemRemainingTime) Type() proto.APLValueType
• type Shaman
  • func NewShaman(character *core.Character, talents string) *Shaman
  • func (shaman *Shaman) AddRaidBuffs(_ *proto.RaidBuffs)
  • func (shaman *Shaman) ApplyFlametongueImbue(procMask core.ProcMask)
  • func (shaman *Shaman) ApplyFlametongueImbueToItem(item *core.Item)
  • func (shaman *Shaman) ApplyFrostbrandImbue(procMask core.ProcMask)
  • func (shaman *Shaman) ApplyFrostbrandImbueToItem(item *core.Item)
  • func (shaman *Shaman) ApplyRockbiterImbue(procMask core.ProcMask)
  • func (shaman *Shaman) ApplyRockbiterImbueToItem(item *core.Item)
  • func (shaman *Shaman) ApplyRunes()
  • func (shaman *Shaman) ApplyTalents()
  • func (shaman *Shaman) ApplyWindfuryImbue(procMask core.ProcMask)
  • func (shaman *Shaman) ApplyWindfuryImbueToItem(item *core.Item)
  • func (shaman *Shaman) FrostbrandDebuffAura(target *core.Unit, level int32) *core.Aura
  • func (shaman *Shaman) GetCharacter() *core.Character
  • func (shaman *Shaman) HasRune(rune proto.ShamanRune) bool
  • func (shaman *Shaman) Initialize()
  • func (shaman *Shaman) NewAPLValue(rot *core.APLRotation, config *proto.APLValue) core.APLValue
  • func (shaman *Shaman) NewSpiritWolf(index int) *SpiritWolf
  • func (shaman *Shaman) RegisterFlametongueImbue(procMask core.ProcMask)
  • func (shaman *Shaman) RegisterFrostbrandImbue(procMask core.ProcMask)
  • func (shaman *Shaman) RegisterHealingSpells()
  • func (shaman *Shaman) RegisterOnItemSwapWithImbue(effectID int32, procMask *core.ProcMask, aura *core.Aura)
  • func (shaman *Shaman) RegisterRockbiterImbue(procMask core.ProcMask)
  • func (shaman *Shaman) RegisterWindfuryImbue(procMask core.ProcMask)
  • func (shaman *Shaman) Reset(_ *core.Simulation)
  • func (shaman *Shaman) ShockCD() time.Duration
• type ShamanAgent
• type SpiritWolf
  • func (spiritWolf *SpiritWolf) ExecuteCustomRotation(_ *core.Simulation)
  • func (spiritWolf *SpiritWolf) GetPet() *core.Pet
  • func (spiritWolf *SpiritWolf) Initialize()
  • func (spiritWolf *SpiritWolf) Reset(sim *core.Simulation)
• type SpiritWolves
  • func (SpiritWolves *SpiritWolves) CancelGCDTimer(sim *core.Simulation)
  • func (SpiritWolves *SpiritWolves) EnableWithTimeout(sim *core.Simulation)

Constants

const (
	StormfuryTotem           = 31031
	TotemOfAncestralGuidance = 32330
	TotemOfStorms            = 23199
	TotemOfTheVoid           = 28248
	TotemOfHex               = 40267
	VentureCoLightningRod    = 38361
	ThunderfallTotem         = 45255
)

Totem Item IDs

const (
	TotemOfRage              = 22395
	TotemOfTheStorm          = 23199
	TotemOfSustaining        = 23200
	TotemCarvedDriftwoodIcon = 209575
	TotemInvigoratingFlame   = 215436
	TotemTormentedAncestry   = 220607
	TerrestrisTank           = 224279
	TotemOfThunder           = 228176
	TotemOfRagingFire        = 228177
	TotemOfEarthenVitality   = 228178
	NaturalAlignmentCrystal  = 230273
	WushoolaysCharmOfSpirits = 231281
	TerrestrisEle            = 231890
)

Totem Item IDs

const (
	SpellFlagShaman    = core.SpellFlagAgentReserved1
	SpellFlagTotem     = core.SpellFlagAgentReserved2
	SpellFlagLightning = core.SpellFlagAgentReserved3
	SpellFlagFocusable = core.SpellFlagAgentReserved4
	SpellFlagMaelstrom = core.SpellFlagAgentReserved5
)

const (
	AirTotem int = iota
	EarthTotem
	FireTotem
	WaterTotem
)

Indexes into NextTotemDrops for self buffs

const (
	SpellCode_ShamanNone int32 = iota

	SpellCode_ShamanChainHeal
	SpellCode_ShamanChainLightning
	SpellCode_ShamanEarthShock
	SpellCode_ShamanFireNova
	SpellCode_ShamanFireNovaTotem
	SpellCode_ShamanFlameShock
	SpellCode_ShamanFrostShock
	SpellCode_ShamanHealingWave
	SpellCode_ShamanLesserHealingWave
	SpellCode_ShamanLightningBolt
	SpellCode_ShamanLightningShield
	SpellCode_ShamanLavaBurst
	SpellCode_ShamanMagmaTotem
	SpellCode_ShamanMoltenBlast
	SpellCode_ShamanSearingTotem
	SpellCode_ShamanStormstrike
)

const AncestralAwakeningHealMultiplier = 0.3

const (
	// This could be value or bitflag if we ended up needing multiple flags at the same time.
	//1 to 5 are used by MaelstromWeapon Stacks
	CastTagLightningOverload int32 = 6
)

const CastTagOverload = 6

This could be value or bitflag if we ended up needing multiple flags at the same time. 1 to 5 are used by MaelstromWeapon Stacks

const ChainHealRanks = 3

const ChainHealTargetCount = int32(3)

const ChainLightningRanks = 4

const ChainLightningTargetCount = int32(3)

const EarthShockRanks = 7

const FireNovaTotemRanks = 5

const FlameShockRanks = 6

const FlametongueWeaponRanks = 6

const FrostShockRanks = 4

const FrostbrandWeaponRanks = 5

const GraceOfAirTotemRanks = 3

const HealingStreamTotemRanks = 5

const HealingWaveRanks = 10

const LesserHealingWaveRanks = 6

const LightningBoltRanks = 10

const LightningShieldRanks = 7

const MagmaTotemRanks = 4

const ManaSpringTotemRanks = 4

const RockbiterWeaponRanks = 7

const SearingTotemRanks = 6

const ShamanMoltenBlastResetChance = .10

const ShamanOverloadChance = .50

const StoneskinTotemRanks = 6

const StrengthOfEarthTotemRanks = 5

const WindfuryTotemRanks = 3

const WindfuryWeaponRanks = 4

const WindwallTotemRanks = 3

Variables

var BurnFlameShockBonusTicks = int32(2)

var BurnFlameShockDamageBonus = 1.0

var BurnFlameShockTargetCount = int32(5)

var BurnSpellPowerPerLevel = int32(2)

var ChainHealBaseHealing = [ChainHealRanks + 1][]float64{{0}, {332, 381}, {416, 477}, {567, 646}}

var ChainHealCastTime = [ChainHealRanks + 1]int32{0, 2500, 2500, 2500}

var ChainHealLevel = [ChainHealRanks + 1]int{0, 40, 46, 54}

var ChainHealManaCost = [ChainHealRanks + 1]float64{0, 260, 315, 405}

var ChainHealSpellCoef = [ChainHealRanks + 1]float64{0, .714, .714, .714}

var ChainHealSpellId = [ChainHealRanks + 1]int32{0, 1064, 10622, 10623}

var ChainLightningBaseDamage = [ChainLightningRanks + 1][]float64{{0}, {200, 227}, {288, 323}, {383, 430}, {505, 564}}

var ChainLightningLevel = [ChainLightningRanks + 1]int{0, 32, 40, 48, 56}

var ChainLightningManaCost = [ChainLightningRanks + 1]float64{0, 280, 380, 490, 605}

var ChainLightningSpellCoef = [ChainLightningRanks + 1]float64{0, .714, .714, .714, .714}

var ChainLightningSpellId = [ChainLightningRanks + 1]int32{0, 421, 930, 2860, 10605}

var EarthShockBaseDamage = [EarthShockRanks + 1][]float64{{0}, {19, 22}, {35, 38}, {65, 69}, {120, 129}, {233, 247}, {364, 387}, {517, 545}}

var EarthShockLevel = [EarthShockRanks + 1]int{0, 4, 8, 14, 24, 36, 48, 60}

var EarthShockManaCost = [EarthShockRanks + 1]float64{0, 30, 50, 85, 145, 240, 345, 450}

var EarthShockSpellCoef = [EarthShockRanks + 1]float64{0, .154, .212, .299, .386, .386, .386, .386}

var EarthShockSpellId = [EarthShockRanks + 1]int32{0, 8042, 8044, 8045, 8046, 10412, 10413, 10414}

var FireNovaSpellCoeff = [FireNovaTotemRanks + 1]float64{0, .214, .214, .214, .214, .214}

var FireNovaSpellId = [FireNovaTotemRanks + 1]int32{0, 408341, 408342, 408343, 408427, 408345}

var FireNovaTotemAoeSpellId = [FireNovaTotemRanks + 1]int32{0, 8349, 8502, 8503, 11306, 11307}

var FireNovaTotemBaseDamage = [FireNovaTotemRanks + 1][]float64{{0, 0}, {53, 62}, {110, 124}, {195, 219}, {295, 331}, {413, 459}}

var FireNovaTotemLevel = [FireNovaTotemRanks + 1]int{0, 12, 22, 32, 42, 52}

var FireNovaTotemManaCost = [FireNovaTotemRanks + 1]float64{0, 95, 170, 280, 395, 520}

var FireNovaTotemSpellCoeff = [FireNovaTotemRanks + 1]float64{0, .1, .143, .143, .143, .143}

var FireNovaTotemSpellId = [FireNovaTotemRanks + 1]int32{0, 1535, 8498, 8499, 11314, 11315}

var FlameShockBaseDamage = [FlameShockRanks + 1]float64{0, 25, 51, 95, 164, 245, 292}

var FlameShockBaseDotDamage = [FlameShockRanks + 1]float64{0, 28, 48, 96, 168, 256, 320}

var FlameShockBaseSpellCoef = [FlameShockRanks + 1]float64{0, .134, .198, .214, .214, .214, .214}

var FlameShockDotSpellCoef = [FlameShockRanks + 1]float64{0, .063, .093, .1, .1, .1, .1}

var FlameShockLevel = [FlameShockRanks + 1]int{0, 10, 18, 28, 40, 52, 60}

var FlameShockManaCost = [FlameShockRanks + 1]float64{0, 55, 95, 160, 250, 345, 410}

var FlameShockSpellId = [FlameShockRanks + 1]int32{0, 8050, 8052, 8053, 10447, 10448, 29228}

var FlametongueWeaponEnchantId = [FlametongueWeaponRanks + 1]int32{0, 5, 4, 3, 523, 1665, 1666}

var FlametongueWeaponMaxDamage = [FlametongueWeaponRanks + 1]float64{0, 18, 26, 42, 57, 85, 112}

var FlametongueWeaponRankByLevel = map[int32]int32{
	25: 2,
	40: 4,
	50: 5,
	60: 6,
}

var FlametongueWeaponSpellId = [FlametongueWeaponRanks + 1]int32{0, 8024, 8027, 8030, 16339, 16341, 16342}

var FrostShockBaseDamage = [FrostShockRanks + 1][]float64{{0}, {95, 101}, {215, 230}, {343, 363}, {492, 520}}

var FrostShockLevel = [FrostShockRanks + 1]int{0, 20, 34, 46, 58}

var FrostShockManaCost = [FrostShockRanks + 1]float64{0, 115, 225, 325, 430}

var FrostShockSpellCoef = [FrostShockRanks + 1]float64{0, .386, .386, .386, .386}

var FrostShockSpellId = [FrostShockRanks + 1]int32{0, 8056, 8058, 10472, 10473}

var FrostbrandWeaponBaseDamage = [FrostbrandWeaponRanks + 1]float64{0, 46, 77, 94, 142, 187}

var FrostbrandWeaponEnchantId = [FrostbrandWeaponRanks + 1]int32{0, 2, 12, 524, 1667, 1668}

var FrostbrandWeaponLevel = [FrostbrandWeaponRanks + 1]int32{0, 20, 28, 38, 48, 58}

var FrostbrandWeaponRankByLevel = map[int32]int32{
	25: 1,
	40: 3,
	50: 4,
	60: 5,
}

var FrostbrandWeaponSpellId = [FrostbrandWeaponRanks + 1]int32{0, 8033, 8038, 10456, 16355, 16356}

var GraceOfAirTotemLevel = [GraceOfAirTotemRanks + 1]int{0, 42, 56, 60}

var GraceOfAirTotemManaCost = [GraceOfAirTotemRanks + 1]float64{0, 155, 250, 310}

var GraceOfAirTotemSpellId = [GraceOfAirTotemRanks + 1]int32{0, 8835, 10627, 25359}

var HealingStreamTotemBaseHealing = [HealingStreamTotemRanks + 1]float64{0, 6, 8, 10, 12, 14}

var HealingStreamTotemHealId = [HealingStreamTotemRanks + 1]int32{0, 5672, 6371, 6372, 10460, 10461}

var HealingStreamTotemLevel = [HealingStreamTotemRanks + 1]int{0, 20, 30, 40, 50, 60}

var HealingStreamTotemManaCost = [HealingStreamTotemRanks + 1]float64{0, 40, 50, 60, 70, 80}

var HealingStreamTotemSpellCoeff = [HealingStreamTotemRanks + 1]float64{0, .022, .022, .022, .022, .022}

var HealingStreamTotemSpellId = [HealingStreamTotemRanks + 1]int32{0, 5394, 6375, 6377, 10462, 10463}

var HealingWaveBaseHealing = [HealingWaveRanks + 1][]float64{{0}, {36, 47}, {69, 83}, {136, 163}, {279, 328}, {378, 443}, {552, 639}, {759, 874}, {1026, 1177}, {1389, 1583}, {1620, 1850}}

var HealingWaveCastTime = [HealingWaveRanks + 1]int32{0, 1500, 2000, 2500, 3000, 3000, 3000, 3000, 3000, 3000, 3000}

var HealingWaveLevel = [HealingWaveRanks + 1]int{0, 1, 6, 12, 18, 24, 32, 40, 48, 56, 60}

var HealingWaveManaCost = [HealingWaveRanks + 1]float64{0, 25, 45, 80, 155, 200, 265, 340, 440, 560, 620}

var HealingWaveSpellCoef = [HealingWaveRanks + 1]float64{0, .123, .271, .5, .793, .857, .857, .857, .857, .857, .857}

var HealingWaveSpellId = [HealingWaveRanks + 1]int32{0, 331, 332, 547, 913, 939, 959, 8005, 10395, 10396, 25357}

var ItemSetAugursRegalia = core.NewItemSet(core.ItemSet{
	Name: "Augur's Regalia",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.AddStat(stats.Defense, 7)
		},

		3: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.AddStat(stats.Block, 10*core.BlockRatingPerBlockChance)
		},

		5: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			if !shaman.HasRune(proto.ShamanRune_RuneWaistPowerSurge) {
				return
			}

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - ZG - Shaman - Tank 5P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					shaman.powerSurgeProcChance += .05
				},
			}))
		},
	},
})

var ItemSetBloodGuardsInscribedMail = core.NewItemSet(core.ItemSet{
	Name: "Blood Guard's Inscribed Mail",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 15)
		},
		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.HealingPower, 33)
		},
	},
})

var ItemSetBloodGuardsMail = core.NewItemSet(core.ItemSet{
	Name: "Blood Guard's Mail",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 15)
		},
		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.AttackPower, 30)
		},
	},
})

var ItemSetBloodGuardsPulsingMail = core.NewItemSet(core.ItemSet{
	Name: "Blood Guard's Pulsing Mail",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 15)
		},
		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.SpellPower, 18)
		},
	},
})

var ItemSetChampionsEarthshaker = core.NewItemSet(core.ItemSet{
	Name: "Champion's Earthshaker",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStats(stats.Stats{
				stats.AttackPower:       40,
				stats.RangedAttackPower: 40,
			})
		},

		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.GetOrRegisterAura(core.Aura{
				Label:    "Shaman Shock Crit Bonus",
				ActionID: core.ActionID{SpellID: 22804},
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					aura.Activate(sim)
				},
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range core.Flatten([][]*core.Spell{shaman.EarthShock, shaman.FlameShock, shaman.FrostShock}) {
						if spell != nil {
							spell.BonusCritRating += 2 * core.CritRatingPerCritChance
						}
					}
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range core.Flatten([][]*core.Spell{shaman.EarthShock, shaman.FlameShock, shaman.FrostShock}) {
						if spell != nil {
							spell.BonusCritRating -= 2 * core.CritRatingPerCritChance
						}
					}
				},
			})
		},

		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 20)
		},
	},
})

var ItemSetChampionsThunderfist = core.NewItemSet(core.ItemSet{
	Name: "Champion's Thunderfist",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.SpellPower, 23)
		},

		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.GetOrRegisterAura(core.Aura{
				Label:    "Shaman Shock Crit Bonus",
				ActionID: core.ActionID{SpellID: 22804},
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					aura.Activate(sim)
				},
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range core.Flatten([][]*core.Spell{shaman.EarthShock, shaman.FlameShock, shaman.FrostShock}) {
						if spell != nil {
							spell.BonusCritRating += 2 * core.CritRatingPerCritChance
						}
					}
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range core.Flatten([][]*core.Spell{shaman.EarthShock, shaman.FlameShock, shaman.FrostShock}) {
						if spell != nil {
							spell.BonusCritRating -= 2 * core.CritRatingPerCritChance
						}
					}
				},
			})
		},

		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 20)
		},
	},
})

var ItemSetChampionsWartide = core.NewItemSet(core.ItemSet{
	Name: "Champion's Wartide",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.HealingPower, 44)
		},

		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.GetOrRegisterAura(core.Aura{
				Label:    "Shaman Shock Crit Bonus",
				ActionID: core.ActionID{SpellID: 22804},
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					aura.Activate(sim)
				},
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range core.Flatten([][]*core.Spell{shaman.EarthShock, shaman.FlameShock, shaman.FrostShock}) {
						if spell != nil {
							spell.BonusCritRating += 2 * core.CritRatingPerCritChance
						}
					}
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range core.Flatten([][]*core.Spell{shaman.EarthShock, shaman.FlameShock, shaman.FrostShock}) {
						if spell != nil {
							spell.BonusCritRating -= 2 * core.CritRatingPerCritChance
						}
					}
				},
			})
		},

		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 20)
		},
	},
})

var ItemSetEarthfuryEruption = core.NewItemSet(core.ItemSet{
	Name: "Earthfury Eruption",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {

		},

		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.GetOrRegisterAura(core.Aura{
				Label:    "S03 - Item - T1 - Shaman - Elemental 4P Bonus",
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					aura.Activate(sim)
				},
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellCode == SpellCode_ShamanLightningBolt && spell.ProcMask.Matches(core.ProcMaskSpellDamage) && result.DidCrit() && sim.Proc(.35, "Power Surge") {
						shaman.PowerSurgeDamageAura.Activate(sim)
					}
				},
			})
		},

		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			core.MakePermanent(shaman.GetOrRegisterAura(core.Aura{
				Label: "S03 - Item - T1 - Shaman - Elemental 6P Bonus",
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if spell.SpellCode == SpellCode_ShamanLavaBurst {
						for _, spell := range shaman.FlameShock {
							if spell == nil {
								continue
							}

							if dot := spell.Dot(shaman.CurrentTarget); dot.IsActive() {
								dot.NumberOfTicks = dot.OriginalNumberOfTicks
								dot.Rollover(sim)
							}
						}
					}
				},
			}))
		},
	},
})

var ItemSetEarthfuryImpact = core.NewItemSet(core.ItemSet{
	Name: "Earthfury Impact",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {

		},

		4: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStats(stats.Stats{
				stats.MeleeCrit: 2 * core.CritRatingPerCritChance,
				stats.SpellCrit: 2 * core.CritRatingPerCritChance,
			})
		},

		6: func(agent core.Agent) {

		},
	},
})

var ItemSetEarthfuryRelief = core.NewItemSet(core.ItemSet{
	Name: "Earthfury Relief",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {

		},

		4: func(agent core.Agent) {

		},

		6: func(agent core.Agent) {

		},
	},
})

var ItemSetEarthfuryResolve = core.NewItemSet(core.ItemSet{
	Name: "Earthfury Resolve",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()

			flurryAura := shaman.makeFlurryAura(5)

			shaman.makeFlurryConsumptionTrigger(flurryAura)

			core.MakePermanent(shaman.GetOrRegisterAura(core.Aura{
				Label: "S03 - Item - T1 - Shaman - Tank 2P Bonus",
				OnSpellHitTaken: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if result.DidParry() || result.DidDodge() || result.DidBlock() {
						flurryAura.Activate(sim)
						flurryAura.SetStacks(sim, 3)
					}
				},
			}))
		},

		4: func(agent core.Agent) {

		},

		6: func(agent core.Agent) {

		},
	},
})

var ItemSetElectromanticStormbringer = core.NewItemSet(core.ItemSet{
	Name: "Electromantic Stormbringer's Chain",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.SpellPower, 12)
		},
		3: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.OnSpellRegistered(func(spell *core.Spell) {
				if spell.SpellCode == SpellCode_ShamanLightningBolt {
					spell.DefaultCast.CastTime -= time.Millisecond * 100
				}
			})
		},
	},
})

var ItemSetEmeraldChainmail = core.NewItemSet(core.ItemSet{
	Name: "Emerald Chainmail",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 10)
		},
		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.SpellPower, 12)
		},
	},
})

var ItemSetEmeraldLadenChain = core.NewItemSet(core.ItemSet{
	Name: "Emerald Laden Chain",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 10)
		},
		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.HealingPower, 22)
		},
	},
})

var ItemSetEmeraldScalemail = core.NewItemSet(core.ItemSet{
	Name: "Emerald Scalemail",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 10)
		},
		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.AttackPower, 20)
		},
	},
})

var ItemSetEruptionOfTheTenStorms = core.NewItemSet(core.ItemSet{
	Name: "Eruption of the Ten Storms",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			if !shaman.Talents.ElementalFocus {
				return
			}

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Elemental 2P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.Flags.Matches(SpellFlagShaman) && result.DidCrit() {
						shaman.ClearcastingAura.Activate(sim)
					}
				},
			}))
		},

		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			if !shaman.HasRune(proto.ShamanRune_RuneFeetSpiritOfTheAlpha) {
				return
			}

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Elemental 4P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					oldOnGain := shaman.LoyalBetaAura.OnGain
					shaman.LoyalBetaAura.OnGain = func(aura *core.Aura, sim *core.Simulation) {
						oldOnGain(aura, sim)
						shaman.PseudoStats.SchoolDamageDealtMultiplier[stats.SchoolIndexFrost] *= 1.05
						shaman.PseudoStats.SchoolDamageDealtMultiplier[stats.SchoolIndexFire] *= 1.05
						shaman.PseudoStats.SchoolDamageDealtMultiplier[stats.SchoolIndexNature] *= 1.05
					}
				},
			}))
		},

		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			if !shaman.Talents.ElementalFocus {
				return
			}

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Elemental 6P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					oldOnGain := shaman.ClearcastingAura.OnGain
					oldOnExpire := shaman.ClearcastingAura.OnExpire
					affectedSpells := shaman.getClearcastingSpells()

					shaman.ClearcastingAura.OnGain = func(aura *core.Aura, sim *core.Simulation) {
						oldOnGain(aura, sim)
						core.Each(affectedSpells, func(spell *core.Spell) {
							spell.DamageMultiplier *= 1.30
						})
					}
					shaman.ClearcastingAura.OnExpire = func(aura *core.Aura, sim *core.Simulation) {
						oldOnExpire(aura, sim)
						core.Each(affectedSpells, func(spell *core.Spell) {
							spell.DamageMultiplier /= 1.30
						})
					}
				},
			}))
		},
	},
})

var ItemSetImpactOfTheTenStorms = core.NewItemSet(core.ItemSet{
	Name: "Impact of the Ten Storms",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			if !shaman.HasRune(proto.ShamanRune_RuneWaistMaelstromWeapon) {
				return
			}

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Enhancement 2P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					oldPPMM := shaman.maelstromWeaponPPMM
					newPPMM := shaman.AutoAttacks.NewPPMManager(oldPPMM.GetPPM()*2, core.ProcMaskMelee)
					shaman.maelstromWeaponPPMM = &newPPMM
				},
			}))
		},

		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()

			var affectedSpells []*core.Spell
			affectedSpellcodes := []int32{SpellCode_ShamanLightningBolt, SpellCode_ShamanChainLightning, SpellCode_ShamanEarthShock, SpellCode_ShamanFlameShock, SpellCode_ShamanFrostShock}
			stormfuryAura := shaman.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 467880},
				Label:    "Stormfury",
				Duration: time.Second * 10,
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					affectedSpells = core.FilterSlice(shaman.Spellbook, func(spell *core.Spell) bool {
						return slices.Contains(affectedSpellcodes, spell.SpellCode)
					})
				},
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					core.Each(affectedSpells, func(spell *core.Spell) {
						spell.BonusCritRating += 100 * core.SpellCritRatingPerCritChance
					})
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					core.Each(affectedSpells, func(spell *core.Spell) {
						spell.BonusCritRating -= 100 * core.SpellCritRatingPerCritChance
					})
				},
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if slices.Contains(affectedSpellcodes, spell.SpellCode) {
						aura.Deactivate(sim)
					}
				},
			})

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Enhancement 4P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellCode == SpellCode_ShamanStormstrike && result.DidCrit() {
						stormfuryAura.Activate(sim)
					}
				},
			}))
		},

		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			if !shaman.HasRune(proto.ShamanRune_RuneWaistMaelstromWeapon) {
				return
			}

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Enhancement 6P Bonus",
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if spell.Flags.Matches(SpellFlagMaelstrom) && spell.CurCast.CastTime == 0 {

						core.StartDelayedAction(sim, core.DelayedActionOptions{
							DoAt: sim.CurrentTime + time.Millisecond*1,
							OnAction: func(sim *core.Simulation) {
								shaman.MaelstromWeaponAura.Activate(sim)
								shaman.MaelstromWeaponAura.AddStack(sim)
							},
						})
					}
				},
			}))
		},
	},
})

var ItemSetResolveOfTheTenStorms = core.NewItemSet(core.ItemSet{
	Name: "Resolve of the Ten Storms",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()

			shieldBlockAura := shaman.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 467891},
				Label:    "Shield Block",
				Duration: time.Second * 5,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					shaman.AddStatDynamic(sim, stats.Block, 30*core.BlockRatingPerBlockChance)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					shaman.AddStatDynamic(sim, stats.Block, -30*core.BlockRatingPerBlockChance)
				},
				OnSpellHitTaken: func(aura *core.Aura, sim *core.Simulation, _ *core.Spell, result *core.SpellResult) {
					if result.DidBlock() {
						aura.Deactivate(sim)
					}
				},
			})

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Tank 2P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellCode == SpellCode_ShamanFlameShock {
						shieldBlockAura.Activate(sim)
					}
				},
			}))
		},

		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()

			statDeps := []*stats.StatDependency{
				nil,
				shaman.NewDynamicMultiplyStat(stats.BlockValue, 1.10),
				shaman.NewDynamicMultiplyStat(stats.BlockValue, 1.20),
				shaman.NewDynamicMultiplyStat(stats.BlockValue, 1.30),
			}

			blockAura := shaman.RegisterAura(core.Aura{
				ActionID:  core.ActionID{SpellID: 467909},
				Label:     "S03 - Item - T2 - Shaman - Tank 4P Bonus",
				Duration:  time.Second * 6,
				MaxStacks: 3,
				OnStacksChange: func(aura *core.Aura, sim *core.Simulation, oldStacks, newStacks int32) {
					if oldStacks != 0 {
						shaman.DisableDynamicStatDep(sim, statDeps[oldStacks])
					}
					if newStacks != 0 {
						shaman.EnableDynamicStatDep(sim, statDeps[newStacks])
					}
				},
			})

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Tank 4P Bonus Trigger",
				OnSpellHitTaken: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if result.DidBlock() {
						blockAura.Activate(sim)
						blockAura.AddStack(sim)
					}
				},
			}))
		},

		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			if !shaman.HasRune(proto.ShamanRune_RuneWaistMaelstromWeapon) {
				return
			}

			core.MakePermanent(shaman.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Shaman - Tank 6P Bonus",
				OnSpellHitTaken: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if result.DidBlock() && sim.Proc(0.50, "T2 6P Proc Maelstrom Weapon") {
						shaman.MaelstromWeaponAura.Activate(sim)
						shaman.MaelstromWeaponAura.AddStack(sim)
					}
				},
			}))
		},
	},
})

var ItemSetTheFiveThunders = core.NewItemSet(core.ItemSet{
	Name: "The Five Thunders",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStats(stats.Stats{
				stats.AttackPower:       40,
				stats.RangedAttackPower: 40,
				stats.SpellDamage:       23,
				stats.HealingPower:      44,
			})
		},

		4: func(agent core.Agent) {
			c := agent.GetCharacter()

			procAura := c.NewTemporaryStatsAura("The Furious Storm", core.ActionID{SpellID: 27775}, stats.Stats{stats.SpellPower: 95}, time.Second*10)
			handler := func(sim *core.Simulation, spell *core.Spell, _ *core.SpellResult) {
				procAura.Activate(sim)
			}

			core.MakeProcTriggerAura(&c.Unit, core.ProcTrigger{
				Name:       "Item - The Furious Storm Proc (MH Auto)",
				Callback:   core.CallbackOnSpellHitDealt,
				Outcome:    core.OutcomeLanded,
				ProcMask:   core.ProcMaskMeleeMHAuto,
				ProcChance: 0.06,
				Handler:    handler,
			})
			core.MakeProcTriggerAura(&c.Unit, core.ProcTrigger{
				Name:       "Item - The Furious Storm Proc (Spell Cast)",
				Callback:   core.CallbackOnCastComplete,
				ProcMask:   core.ProcMaskSpellDamage | core.ProcMaskSpellHealing,
				ProcChance: 0.04,
				Handler:    handler,
			})
		},

		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddResistances(8)
		},

		8: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Armor, 200)
		},
	},
})

var LesserHealingWaveBaseHealing = [LesserHealingWaveRanks + 1][]float64{{0}, {170, 195}, {257, 292}, {347, 391}, {473, 529}, {649, 723}, {832, 928}}

var LesserHealingWaveCastTime = [LesserHealingWaveRanks + 1]int32{0, 1500, 1500, 1500, 1500, 1500, 1500}

var LesserHealingWaveLevel = [LesserHealingWaveRanks + 1]int{0, 20, 28, 36, 44, 52, 60}

var LesserHealingWaveManaCost = [LesserHealingWaveRanks + 1]float64{0, 105, 145, 185, 235, 305, 380}

var LesserHealingWaveSpellCoef = [LesserHealingWaveRanks + 1]float64{0, .429, .429, .429, .429, .429, .429}

var LesserHealingWaveSpellId = [LesserHealingWaveRanks + 1]int32{0, 8004, 8008, 8010, 10466, 10467, 10468}

var LightningBoltBaseDamage = [LightningBoltRanks + 1][]float64{{0}, {15, 17}, {28, 33}, {48, 57}, {88, 100}, {131, 149}, {179, 202}, {230, 259}, {145, 163}, {347, 389}, {428, 477}}

var LightningBoltCastTime = [LightningBoltRanks + 1]int32{0, 1500, 2000, 2500, 3000, 3000, 3000, 3000, 3000, 3000, 3000}

var LightningBoltLevel = [LightningBoltRanks + 1]int{0, 1, 8, 14, 20, 26, 32, 38, 44, 50, 56}

var LightningBoltManaCost = [LightningBoltRanks + 1]float64{0, 15, 30, 45, 75, 105, 135, 165, 195, 230, 265}

var LightningBoltSpellCoef = [LightningBoltRanks + 1]float64{0, .1233, .314, .554, .857, .857, .857, .857, .857, .857, .857}

var LightningBoltSpellId = [LightningBoltRanks + 1]int32{0, 403, 529, 548, 915, 943, 6041, 10391, 10392, 15207, 15208}

var LightningShieldBaseDamage = [LightningShieldRanks + 1]float64{0, 13, 29, 51, 80, 114, 154, 198}

var LightningShieldLevel = [LightningShieldRanks + 1]int{0, 8, 16, 24, 32, 40, 48, 56}

var LightningShieldManaCost = [LightningShieldRanks + 1]float64{0, 45, 80, 125, 180, 240, 305}

var LightningShieldOverchargedProcSpellId = [LightningShieldRanks + 1]int32{0, 432143, 432144, 432145, 432146, 432147, 432148, 432149}

var LightningShieldProcSpellId = [LightningShieldRanks + 1]int32{0, 26364, 26365, 26366, 26367, 26369, 26370, 26363}

var LightningShieldSpellCoef = [LightningShieldRanks + 1]float64{0, .147, .227, .267, .267, .267, .267, .267}

var LightningShieldSpellId = [LightningShieldRanks + 1]int32{0, 324, 325, 905, 945, 8134, 10431, 10432}

var MagmaTotemAoeSpellId = [MagmaTotemRanks + 1]int32{0, 8187, 10579, 10580, 10581}

var MagmaTotemBaseDamage = [MagmaTotemRanks + 1]float64{0, 22, 37, 54, 75}

var MagmaTotemLevel = [MagmaTotemRanks + 1]int{0, 26, 36, 46, 56}

var MagmaTotemManaCost = [MagmaTotemRanks + 1]float64{0, 230, 360, 500, 650}

var MagmaTotemSpellCoeff = [MagmaTotemRanks + 1]float64{0, .033, .033, .033, .033}

var MagmaTotemSpellId = [MagmaTotemRanks + 1]int32{0, 8190, 10585, 10586, 10587}

var ManaSpringTotemLevel = [ManaSpringTotemRanks + 1]int{0, 26, 36, 46, 56}

var ManaSpringTotemManaCost = [ManaSpringTotemRanks + 1]float64{0, 40, 60, 80, 100}

var ManaSpringTotemManaRestore = [ManaSpringTotemRanks + 1]int32{0, 4, 6, 8, 10}

var ManaSpringTotemSpellId = [ManaSpringTotemRanks + 1]int32{0, 5675, 10495, 10496, 10497}

var OstracizedBerserksBattlemail = core.NewItemSet(core.ItemSet{
	Name: "Ostracized Berserker's Battlemail",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.AttackPower, 20)
		},
		3: func(agent core.Agent) {
			c := agent.GetCharacter()

			procAura := c.GetOrRegisterAura(core.Aura{
				Label:     "Fiery Strength Proc",
				ActionID:  core.ActionID{SpellID: 449932},
				Duration:  time.Second * 12,
				MaxStacks: 10,
				OnStacksChange: func(aura *core.Aura, sim *core.Simulation, oldStacks, newStacks int32) {
					statsDelta := float64(newStacks-oldStacks) * 5.0
					aura.Unit.AddStatDynamic(sim, stats.AttackPower, statsDelta)
				},
			})

			core.MakeProcTriggerAura(&c.Unit, core.ProcTrigger{
				Name:     "Fiery Strength",
				Callback: core.CallbackOnSpellHitDealt | core.CallbackOnPeriodicDamageDealt,
				Outcome:  core.OutcomeLanded,
				ProcMask: core.ProcMaskDirect,
				Handler: func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellSchool.Matches(core.SpellSchoolFire) {
						procAura.Activate(sim)
						procAura.AddStack(sim)
					}
				},
			})
		},
	},
})

var RockbiterWeaponBonusAP = [RockbiterWeaponRanks + 1]float64{0, 50, 79, 118, 138, 319, 490, 653}

var RockbiterWeaponEnchantId = [RockbiterWeaponRanks + 1]int32{0, 29, 6, 1, 503, 1663, 683, 1664}

var RockbiterWeaponLevel = [RockbiterWeaponRanks + 1]int32{0, 1, 8, 16, 24, 34, 44, 54}

var RockbiterWeaponRankByLevel = map[int32]int32{
	25: 4,
	40: 5,
	50: 6,
	60: 7,
}

var RollingThunderProcChance = .50

var SearingTotemAttackSpellId = [SearingTotemRanks + 1]int32{0, 3606, 6350, 6351, 6352, 10435, 10436}

var SearingTotemBaseDamage = [SearingTotemRanks + 1][]float64{{0}, {9, 11}, {13, 17}, {19, 25}, {26, 34}, {33, 45}, {40, 54}}

var SearingTotemDuration = [SearingTotemRanks + 1]int{0, 30, 35, 40, 45, 50, 55}

var SearingTotemLevel = [SearingTotemRanks + 1]int{0, 10, 20, 30, 40, 50, 60}

var SearingTotemManaCost = [SearingTotemRanks + 1]float64{0, 25, 45, 75, 110, 145, 170}

var SearingTotemSpellCoef = [SearingTotemRanks + 1]float64{0, .052, .083, .083, .083, .083, .083}

var SearingTotemSpellId = [SearingTotemRanks + 1]int32{0, 3599, 6363, 6364, 6365, 10437, 10438}

var StoneskinTotemLevel = [StoneskinTotemRanks + 1]int{0, 4, 14, 24, 34, 44, 54}

var StoneskinTotemManaCost = [StoneskinTotemRanks + 1]float64{0, 30, 60, 90, 115, 160, 210}

var StoneskinTotemSpellId = [StoneskinTotemRanks + 1]int32{0, 8071, 8154, 8155, 10406, 10407, 10408}

var StrengthOfEarthTotemLevel = [StrengthOfEarthTotemRanks + 1]int{0, 10, 24, 38, 52, 60}

var StrengthOfEarthTotemManaCost = [StrengthOfEarthTotemRanks + 1]float64{0, 25, 65, 125, 225, 275}

var StrengthOfEarthTotemSpellId = [StrengthOfEarthTotemRanks + 1]int32{0, 8075, 8160, 8161, 10442, 25361}

var TalentTreeSizes = [3]int{15, 16, 15}

var WindfuryTotemBonusDamage = [WindfuryTotemRanks + 1]float64{0, 122, 229, 315}

var WindfuryTotemLevel = [WindfuryTotemRanks + 1]int{0, 32, 42, 52}

var WindfuryTotemManaCost = [WindfuryTotemRanks + 1]float64{0, 115, 175, 250}

var WindfuryTotemSpellId = [WindfuryTotemRanks + 1]int32{0, 8512, 10613, 10614}

var WindfuryWeaponBonusAP = [WindfuryWeaponRanks + 1]float64{0, 104, 119, 249, 333}

var WindfuryWeaponEnchantId = [WindfuryWeaponRanks + 1]int32{0, 283, 284, 525, 1669}

var WindfuryWeaponLevel = [WindfuryWeaponRanks + 1]int32{0, 30, 40, 50, 60}

var WindfuryWeaponRankByLevel = map[int32]int32{
	25: 0,
	40: 2,
	50: 3,
	60: 4,
}

var WindfuryWeaponSpellId = [WindfuryWeaponRanks + 1]int32{0, 8232, 8235, 10486, 16362}

var WindwallTotemLevel = [WindwallTotemRanks + 1]int{0, 36, 46, 56}

var WindwallTotemManaCost = [WindwallTotemRanks + 1]float64{0, 115, 170, 225}

var WindwallTotemSpellId = [WindwallTotemRanks + 1]int32{0, 15107, 15111, 15112}

Types

type APLValueTotemRemainingTime

type APLValueTotemRemainingTime struct {
	core.DefaultAPLValueImpl
	// contains filtered or unexported fields
}

func (*APLValueTotemRemainingTime) GetDuration

func (value *APLValueTotemRemainingTime) GetDuration(sim *core.Simulation) time.Duration

func (*APLValueTotemRemainingTime) String

func (value *APLValueTotemRemainingTime) String() string

func (*APLValueTotemRemainingTime) Type

func (value *APLValueTotemRemainingTime) Type() proto.APLValueType

type Shaman

type Shaman struct {
	core.Character

	Talents *proto.ShamanTalents

	// Spells
	AncestralAwakening     *core.Spell
	ChainHeal              []*core.Spell
	ChainHealOverload      []*core.Spell
	ChainLightning         []*core.Spell
	ChainLightningOverload []*core.Spell
	EarthShield            *core.Spell
	EarthShock             []*core.Spell
	FeralSpirit            *core.Spell
	FireNova               *core.Spell
	FireNovaTotem          []*core.Spell
	FlameShock             []*core.Spell
	FrostShock             []*core.Spell
	GraceOfAirTotem        []*core.Spell
	HealingStreamTotem     []*core.Spell
	HealingWave            []*core.Spell
	HealingWaveOverload    []*core.Spell
	LavaBurst              *core.Spell
	LavaBurstOverload      *core.Spell
	LavaLash               *core.Spell
	LesserHealingWave      []*core.Spell
	LightningBolt          []*core.Spell
	LightningBoltOverload  []*core.Spell
	LightningShield        []*core.Spell
	LightningShieldProcs   []*core.Spell // The damage component of lightning shield is a separate spell
	MagmaTotem             []*core.Spell
	ManaSpringTotem        []*core.Spell
	MoltenBlast            *core.Spell
	Riptide                *core.Spell
	RollingThunder         *core.Spell
	SearingTotem           []*core.Spell
	StoneskinTotem         []*core.Spell
	StormstrikeMH          *core.Spell
	StormstrikeOH          *core.Spell
	StrengthOfEarthTotem   []*core.Spell
	TremorTotem            *core.Spell
	WaterShield            *core.Spell
	WindfuryTotem          []*core.Spell
	WindwallTotem          []*core.Spell

	// Auras
	ClearcastingAura      *core.Aura
	FlurryAura            *core.Aura
	FlurryConsumptionAura *core.Aura // Trigger aura for consuming Flurry stacks on hit
	LoyalBetaAura         *core.Aura
	MaelstromWeaponAura   *core.Aura
	PowerSurgeDamageAura  *core.Aura
	PowerSurgeHealAura    *core.Aura
	SpiritOfTheAlphaAura  *core.Aura

	// Totems
	ActiveTotems     [4]*core.Spell
	EarthTotems      []*core.Spell
	FireTotems       []*core.Spell
	WaterTotems      []*core.Spell
	AirTotems        []*core.Spell
	Totems           *proto.ShamanTotems
	TotemExpirations [4]time.Duration // The expiration time of each totem (earth, air, fire, water).

	// Shield
	ActiveShield     *core.Spell // Tracks the Shaman's active shield spell
	ActiveShieldAura *core.Aura

	// Pets
	SpiritWolves *SpiritWolves
	// contains filtered or unexported fields
}

Shaman represents a shaman character.

func NewShaman

func NewShaman(character *core.Character, talents string) *Shaman

func (*Shaman) AddRaidBuffs

func (shaman *Shaman) AddRaidBuffs(_ *proto.RaidBuffs)

func (*Shaman) ApplyFlametongueImbue

func (shaman *Shaman) ApplyFlametongueImbue(procMask core.ProcMask)

func (*Shaman) ApplyFlametongueImbueToItem

func (shaman *Shaman) ApplyFlametongueImbueToItem(item *core.Item)

func (*Shaman) ApplyFrostbrandImbue

func (shaman *Shaman) ApplyFrostbrandImbue(procMask core.ProcMask)

func (*Shaman) ApplyFrostbrandImbueToItem

func (shaman *Shaman) ApplyFrostbrandImbueToItem(item *core.Item)

func (*Shaman) ApplyRockbiterImbue

func (shaman *Shaman) ApplyRockbiterImbue(procMask core.ProcMask)

func (*Shaman) ApplyRockbiterImbueToItem

func (shaman *Shaman) ApplyRockbiterImbueToItem(item *core.Item)

func (*Shaman) ApplyRunes

func (shaman *Shaman) ApplyRunes()

func (*Shaman) ApplyTalents

func (shaman *Shaman) ApplyTalents()

func (*Shaman) ApplyWindfuryImbue

func (shaman *Shaman) ApplyWindfuryImbue(procMask core.ProcMask)

func (*Shaman) ApplyWindfuryImbueToItem

func (shaman *Shaman) ApplyWindfuryImbueToItem(item *core.Item)

func (*Shaman) FrostbrandDebuffAura

func (shaman *Shaman) FrostbrandDebuffAura(target *core.Unit, level int32) *core.Aura

func (*Shaman) GetCharacter

func (shaman *Shaman) GetCharacter() *core.Character

func (*Shaman) HasRune

func (shaman *Shaman) HasRune(rune proto.ShamanRune) bool

func (*Shaman) Initialize

func (shaman *Shaman) Initialize()

func (*Shaman) NewAPLValue

func (shaman *Shaman) NewAPLValue(rot *core.APLRotation, config *proto.APLValue) core.APLValue

func (*Shaman) NewSpiritWolf

func (shaman *Shaman) NewSpiritWolf(index int) *SpiritWolf

func (*Shaman) RegisterFlametongueImbue

func (shaman *Shaman) RegisterFlametongueImbue(procMask core.ProcMask)

func (*Shaman) RegisterFrostbrandImbue

func (shaman *Shaman) RegisterFrostbrandImbue(procMask core.ProcMask)

func (*Shaman) RegisterHealingSpells

func (shaman *Shaman) RegisterHealingSpells()

func (*Shaman) RegisterOnItemSwapWithImbue

func (shaman *Shaman) RegisterOnItemSwapWithImbue(effectID int32, procMask *core.ProcMask, aura *core.Aura)

func (*Shaman) RegisterRockbiterImbue

func (shaman *Shaman) RegisterRockbiterImbue(procMask core.ProcMask)

func (*Shaman) RegisterWindfuryImbue

func (shaman *Shaman) RegisterWindfuryImbue(procMask core.ProcMask)

func (*Shaman) Reset

func (shaman *Shaman) Reset(_ *core.Simulation)

func (*Shaman) ShockCD

func (shaman *Shaman) ShockCD() time.Duration

type ShamanAgent

type ShamanAgent interface {
	core.Agent

	// The Shaman controlled by this Agent.
	GetShaman() *Shaman
}

Implemented by each Shaman spec.

type SpiritWolf

type SpiritWolf struct {
	core.Pet
	// contains filtered or unexported fields
}

func (*SpiritWolf) ExecuteCustomRotation

func (spiritWolf *SpiritWolf) ExecuteCustomRotation(_ *core.Simulation)

func (*SpiritWolf) GetPet

func (spiritWolf *SpiritWolf) GetPet() *core.Pet

func (*SpiritWolf) Initialize

func (spiritWolf *SpiritWolf) Initialize()

func (*SpiritWolf) Reset

func (spiritWolf *SpiritWolf) Reset(sim *core.Simulation)

type SpiritWolves

type SpiritWolves struct {
	SpiritWolf1 *SpiritWolf
	SpiritWolf2 *SpiritWolf
}

func (*SpiritWolves) CancelGCDTimer

func (SpiritWolves *SpiritWolves) CancelGCDTimer(sim *core.Simulation)

func (*SpiritWolves) EnableWithTimeout

func (SpiritWolves *SpiritWolves) EnableWithTimeout(sim *core.Simulation)