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) ApplyCrimsonCleaverShamanEffect(aura *core.Aura)
  • 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) ApplyHackAndSmashShamanBonus()
  • func (shaman *Shaman) ApplyMercyShamanEffect(aura *core.Aura)
  • 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) NewSpiritWolves() *SpiritWolves
  • 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) WayOfEarthActive() bool
• type ShamanAgent
• type SpiritWolves
  • func (wolves *SpiritWolves) ExecuteCustomRotation(_ *core.Simulation)
  • func (spiritWolf *SpiritWolves) GetPet() *core.Pet
  • func (wolves *SpiritWolves) Initialize()
  • func (wolves *SpiritWolves) Reset(sim *core.Simulation)

Constants

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

Totem Item IDs

const (
	// Keep these ordered by ID
	TotemOfRage               = 22395
	TotemOfTheStorm           = 23199
	TotemOfSustaining         = 23200
	TotemOfInvigoratingFlame  = 215436
	AncestralBloodstormBeacon = 216615
	TotemOfTormentedAncestry  = 220607
	TerrestrisTank            = 224279
	TotemOfThunder            = 228176
	TotemOfRagingFire         = 228177
	TotemOfEarthenVitality    = 228178
	NaturalAlignmentCrystal   = 230273
	WushoolaysCharmOfSpirits  = 231281
	TerrestrisEle             = 231890
	TotemOfRelentlessThunder  = 232392
	TotemOfTheElements        = 232409
	TotemOfAstralFlow         = 232416
	TotemOfConductiveCurrents = 232419
	TotemOfThunderousStrikes  = 234478
	TotemOfFlowingMagma       = 234479
	TotemOfPyroclasticThunder = 234480
	SignetOfTheEarthshatterer = 236176
	TotemOfUnholyMight        = 237577
	ScarletSmashbringer       = 240921
)

const (
	ClassSpellMask_ShamanNone uint64 = 0

	ClassSpellMask_ShamanAncestralAwakening uint64 = 1 << iota
	ClassSpellMask_ShamanAncestralGuidance
	ClassSpellMask_ShamanAncestralGuidanceDamage
	ClassSpellMask_ShamanAncestralGuidanceHeal
	ClassSpellMask_ShamanChainHeal
	ClassSpellMask_ShamanChainLightning
	ClassSpellMask_ShamanEarthShock
	ClassSpellMask_ShamanFeralSpirit
	ClassSpellMask_ShamanFireNova
	ClassSpellMask_ShamanFireNovaTotemAttack
	ClassSpellMask_ShamanFlameShock
	ClassSpellMask_ShamanFlametongueProc
	ClassSpellMask_ShamanFrostShock
	ClassSpellMask_ShamanHealingWave
	ClassSpellMask_ShamanLavaLash
	ClassSpellMask_ShamanLesserHealingWave
	ClassSpellMask_ShamanLightningBolt
	ClassSpellMask_ShamanLightningShield
	ClassSpellMask_ShamanLightningShieldProc
	ClassSpellMask_ShamanMagmaTotemAttack
	ClassSpellMask_ShamanRollingThunder
	ClassSpellMask_ShamanLavaBurst
	ClassSpellMask_ShamanMoltenBlast
	ClassSpellMask_ShamanRiptide
	ClassSpellMask_ShamanSearingTotemAttack
	ClassSpellMask_ShamanShamanisticRage
	ClassSpellMask_ShamanStormstrike
	ClassSpellMask_ShamanStormstrikeHit
	ClassSpellMask_ShamanWaterShield
	ClassSpellMask_ShamanWindFury

	// Totems should go after this
	ClassSpellMask_ShamanAll = 1<<iota - 1

	// Fire totems
	ClassSpellMask_ShamanFireNovaTotem = 1 << (iota - 1)
	ClassSpellMask_ShamanMagmaTotem
	ClassSpellMask_ShamanSearingTotem
	// Air totems
	ClassSpellMask_ShamanWindFuryTotem
	ClassSpellMask_ShamanGraceOfAirTotem
	ClassSpellMask_ShamanWindwallTotem
	// Earth totems
	ClassSpellMask_ShamanStrengthOfEarthTotem
	ClassSpellMask_ShamanStoneskinTotem
	ClassSpellMask_ShamanTremorTotem
	// Water totems
	ClassSpellMask_ShamanHealingStreamTotem
	ClassSpellMask_ShamanManaSpringTotem

	ClassSpellMask_ShamanShocks = ClassSpellMask_ShamanEarthShock | ClassSpellMask_ShamanFlameShock | ClassSpellMask_ShamanFrostShock

	// Direct healing spells only. See Tidal Mastery talent
	ClassSpellMask_ShamanHealingSpell   = ClassSpellMask_ShamanChainHeal | ClassSpellMask_ShamanHealingWave | ClassSpellMask_ShamanLesserHealingWave | ClassSpellMask_ShamanRiptide
	ClassSpellMask_ShamanLightningSpell = ClassSpellMask_ShamanChainLightning | ClassSpellMask_ShamanLightningBolt | ClassSpellMask_ShamanLightningShield |
		ClassSpellMask_ShamanLightningShieldProc | ClassSpellMask_ShamanRollingThunder

	// Totem groups
	ClassSpellMask_ShamanFireTotem  = ClassSpellMask_ShamanSearingTotem | ClassSpellMask_ShamanMagmaTotem | ClassSpellMask_ShamanFireNovaTotem
	ClassSpellMask_ShamanAirTotem   = ClassSpellMask_ShamanWindFuryTotem | ClassSpellMask_ShamanGraceOfAirTotem | ClassSpellMask_ShamanWindwallTotem
	ClassSpellMask_ShamanEarthTotem = ClassSpellMask_ShamanStrengthOfEarthTotem | ClassSpellMask_ShamanStoneskinTotem | ClassSpellMask_ShamanTremorTotem
	ClassSpellMask_ShamanWaterTotem = ClassSpellMask_ShamanHealingStreamTotem | ClassSpellMask_ShamanManaSpringTotem

	ClassSpellMask_ShamanTotems = ClassSpellMask_ShamanFireTotem | ClassSpellMask_ShamanAirTotem | ClassSpellMask_ShamanEarthTotem | ClassSpellMask_ShamanWaterTotem

	ClassSpellMask_ShamanHarmfulGCDSpells = ClassSpellMask_ShamanLightningBolt | ClassSpellMask_ShamanChainLightning |
		ClassSpellMask_ShamanEarthShock | ClassSpellMask_ShamanFlameShock | ClassSpellMask_ShamanFrostShock |
		ClassSpellMask_ShamanLavaBurst | ClassSpellMask_ShamanLavaLash | ClassSpellMask_ShamanMoltenBlast |
		ClassSpellMask_ShamanFireNova
)

const (
	AirTotem int = iota
	EarthTotem
	FireTotem
	WaterTotem
)

Indexes into NextTotemDrops for self buffs

const AncestralAwakeningHealMultiplier = 0.3

const CastTagOverload = 11

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

const ChainHealRanks = 3

const ChainHealTargetCount = int32(3)

const ChainLightningRanks = 4

const ChainLightningTargetCount = int32(3)

const CrimsonCleaverDamageBonus = 1.20

const EarthShockRanks = 7

const EleTier32pFlameShockDamageBonus = 40

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 MaelstromWeaponBaseStacks = 5

const MaelstromWeaponSplits = 11 // 0-5 stacks + 5 more if using 6pT3.5

const MagmaTotemRanks = 4

const ManaSpringTotemRanks = 4

const MercyDamageBonus = 1.20

const RockbiterWeaponRanks = 7

const SearingTotemRanks = 6

const StoneskinTotemRanks = 6

const StormEarthAndFireFlameShockDamageBonus = 60

const StrengthOfEarthTotemRanks = 5

const WindfuryTotemRanks = 3

const WindfuryWeaponRanks = 4

const WindwallTotemRanks = 3

Variables

var BurnFlameShockBonusTicks = int32(2)

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.applyZGTank3PBonus()
		},

		5: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyZGTank5PBonus()
		},
	},
})

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.applyPhase4PvP4PBonus()
		},

		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.applyPhase4PvP4PBonus()
		},

		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.applyPhase4PvP4PBonus()
		},

		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.applyT1Elemental4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT1Elemental6PBonus()
		},
	},
})

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

		2: func(agent core.Agent) {

		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT1Enhancement4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT1Enhancement6PBonus()
		},
	},
})

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()
			shaman.applyT1Tank2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT1Tank4PBonus()
		},

		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT1Tank6PBonus()
		},
	},
})

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.Matches(ClassSpellMask_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()
			shaman.applyT2Elemental2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Elemental4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Elemental6PBonus()
		},
	},
})

var ItemSetGiftOfTheGatheringStorm = core.NewItemSet(core.ItemSet{
	Name: "Gift of the Gathering Storm",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyRAQElemental3PBonus()
		},
	},
})

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()
			shaman.applyT2Enhancement2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Enhancement4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Enhancement6PBonus()
		},
	},
})

var ItemSetReliefOfTheTenStorms = core.NewItemSet(core.ItemSet{
	Name: "Relief of the Ten Storms",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Restoration2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Restoration4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Restoration6PBonus()
		},
	},
})

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()
			shaman.applyT2Tank2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Tank4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyT2Tank6PBonus()
		},
	},
})

var ItemSetStormcallersEruption = core.NewItemSet(core.ItemSet{
	Name: "Stormcaller's Eruption",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyTAQElemental2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyTAQElemental4PBonus()
		},
	},
})

var ItemSetStormcallersImpact = core.NewItemSet(core.ItemSet{
	Name: "Stormcaller's Impact",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyTAQEnhancement2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyTAQEnhancement4PBonus()
		},
	},
})

var ItemSetStormcallersRelief = core.NewItemSet(core.ItemSet{
	Name: "Stormcaller's Relief",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
		},

		4: func(agent core.Agent) {
		},
	},
})

var ItemSetStormcallersResolve = core.NewItemSet(core.ItemSet{
	Name: "Stormcaller's Resolve",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyTAQTank2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyTAQTank4PBonus()
		},
	},
})

var ItemSetTheEarthshatterersRage = core.NewItemSet(core.ItemSet{
	Name: "The Earthshatterer's Rage",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasEnhancement2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasEnhancement4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasEnhancement6PBonus()
		},
	},
})

var ItemSetTheEarthshatterersResolve = core.NewItemSet(core.ItemSet{
	Name: "The Earthshatterer's Resolve",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasTank2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasTank4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasTank6PBonus()
		},
	},
})

var ItemSetTheEarthshatterersStorm = core.NewItemSet(core.ItemSet{
	Name: "The Earthshatterer's Storm",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasElemental2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasElemental4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyNaxxramasElemental6PBonus()
		},
	},
})

var ItemSetTheEarthshatteres = core.NewItemSet(core.ItemSet{
	Name: "The Earthshatterer",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
		},

		4: func(agent core.Agent) {
		},

		6: func(agent core.Agent) {
		},
	},
})

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 ItemSetTheSoulcrusher = core.NewItemSet(core.ItemSet{
	Name: "The Soulcrusher",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
		},

		4: func(agent core.Agent) {
		},

		6: func(agent core.Agent) {
		},
	},
})

var ItemSetTheSoulcrushersRage = core.NewItemSet(core.ItemSet{
	Name: "The Soulcrusher's Rage",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveEnhancement2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveEnhancement4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveEnhancement6PBonus()
		},
	},
})

var ItemSetTheSoulcrushersResolve = core.NewItemSet(core.ItemSet{
	Name: "The Soulcrusher's Resolve",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveTank2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveTank4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveTank6PBonus()
		},
	},
})

var ItemSetTheSoulcrushersStorm = core.NewItemSet(core.ItemSet{
	Name: "The Soulcrusher's Storm",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveElemental2PBonus()
		},
		4: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveElemental4PBonus()
		},
		6: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.applyScarletEnclaveElemental6PBonus()
		},
	},
})

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

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

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

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

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

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

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

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

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

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

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

		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStats(stats.Stats{
				stats.HealingPower: 88,
				stats.SpellDamage:  15,
			})
		},
	},
})

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 RockbiterWeaponBonusTPS = [RockbiterWeaponRanks + 1]float64{0, 6, 10, 16, 27, 41, 55, 72}

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 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
	ElementalMastery       *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
	Stormstrike            *core.Spell
	StormstrikeMH          *core.Spell
	StormstrikeOH          *core.Spell
	StrengthOfEarthTotem   []*core.Spell
	TremorTotem            *core.Spell
	WaterShield            *core.Spell
	WaterShieldRestore     *core.Spell
	WindfuryTotem          []*core.Spell
	WindfuryWeaponMH       *core.Spell
	WindfuryWeaponOH       *core.Spell
	WindwallTotem          []*core.Spell

	// Auras
	ClearcastingAura     *core.Aura
	LightningShieldAuras []*core.Aura
	LoyalBetaAura        *core.Aura
	MaelstromWeaponAura  *core.Aura
	PowerSurgeDamageAura *core.Aura
	PowerSurgeHealAura   *core.Aura
	ShamanisticRageAura  *core.Aura
	ShieldMasteryAura    *core.Aura
	SpiritOfTheAlphaAura *core.Aura
	WaterShieldAura      *core.Aura

	// Dynamic Class Masks
	MaelstromWeaponClassMask uint64
	MaelstromWeaponSpellMods []*core.SpellMod

	// 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) ApplyCrimsonCleaverShamanEffect

func (shaman *Shaman) ApplyCrimsonCleaverShamanEffect(aura *core.Aura)

Equip: Chance on hit to cause your next 4 instances of Nature damage are increased by 20%. Lasts 12 sec. (100ms cooldown) Confirmed PPM 1.0

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) ApplyHackAndSmashShamanBonus

func (shaman *Shaman) ApplyHackAndSmashShamanBonus()

The Fire and Nature damage increases from Mercy and Crimson Cleaver are increased by 10%.

func (*Shaman) ApplyMercyShamanEffect

func (shaman *Shaman) ApplyMercyShamanEffect(aura *core.Aura)

Equip: Chance on hit to cause your next 4 instances of Fire damage are increased by 20%. Lasts 12 sec. (100ms cooldown) Confirmed PPM 1.0 Note: Not listed but confirmed by Zirene, does not proc from or benefit Flametongue Weapon procs

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) NewSpiritWolves

func (shaman *Shaman) NewSpiritWolves() *SpiritWolves

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) WayOfEarthActive

func (shaman *Shaman) WayOfEarthActive() bool

type ShamanAgent

type ShamanAgent interface {
	core.Agent

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

Implemented by each Shaman spec.

type SpiritWolves

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

func (*SpiritWolves) ExecuteCustomRotation

func (wolves *SpiritWolves) ExecuteCustomRotation(_ *core.Simulation)

func (*SpiritWolves) GetPet

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

func (*SpiritWolves) Initialize

func (wolves *SpiritWolves) Initialize()

func (*SpiritWolves) Reset

func (wolves *SpiritWolves) Reset(sim *core.Simulation)