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) ApplyTalents()
  • func (shaman *Shaman) ApplyWindfuryImbue(procMask core.ProcMask)
  • func (shaman *Shaman) ApplyWindfuryImbueToItem(item *core.Item)
  • func (shaman *Shaman) FrostbrandDebuffAura(target *core.Unit) *core.Aura
  • func (shaman *Shaman) GetCharacter() *core.Character
  • func (shaman *Shaman) Initialize()
  • func (shaman *Shaman) NewAPLValue(rot *core.APLRotation, config *proto.APLValue) core.APLValue
  • func (shaman *Shaman) RegisterFlametongueImbue(procMask core.ProcMask)
  • func (shaman *Shaman) RegisterFrostbrandImbue(procMask core.ProcMask)
  • 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)
• type ShamanAgent

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
	NaturalAlignmentCrystal  = 19344
	WushoolaysCharmOfSpirits = 19956
	TotemOfRage              = 22395
	TotemOfTheStorm          = 23199
)

const (
	SpellFlagShaman    = core.SpellFlagAgentReserved1
	SpellFlagTotem     = core.SpellFlagAgentReserved2
	SpellFlagLightning = core.SpellFlagAgentReserved3
)

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_ShamanFireNovaTotem
	SpellCode_ShamanFlameShock
	SpellCode_ShamanFrostShock
	SpellCode_ShamanHealingWave
	SpellCode_ShamanLesserHealingWave
	SpellCode_ShamanLightningBolt
	SpellCode_ShamanLightningShield
	SpellCode_ShamanMagmaTotem
	SpellCode_ShamanSearingTotem
	SpellCode_ShamanStormstrike
)

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 LightningBoltRanks = 10

const LightningShieldRanks = 7

const MagmaTotemRanks = 4

const ManaSpringTotemRanks = 4

const RockbiterWeaponRanks = 7

const SearingTotemRanks = 6

const StoneskinTotemRanks = 6

const StrengthOfEarthTotemRanks = 5

const WindfuryTotemRanks = 3

const WindfuryWeaponRanks = 4

const WindwallTotemRanks = 3

Variables

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 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 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 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},
				OnInit: 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, 15)
		},
	},
})

var ItemSetChampionsStormcaller = core.NewItemSet(core.ItemSet{
	Name: "Champion's Stormcaller",
	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},
				OnInit: 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 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.RegisterAura(core.Aura{
				Label: "Gift of the Gathering Storm Chain Lightning Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					shaman.ChainLightningBounceCoefficient += 0.05
				},
			})
		},
	},
})

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

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

			buffAura := shaman.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 26121},
				Label:    "Stormcaller's Wrath",
				Duration: time.Second * 8,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					shaman.AddStatDynamic(sim, stats.NaturePower, 50)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					shaman.AddStatDynamic(sim, stats.NaturePower, -50)
				},
			})

			affectedSpellCodes := []int32{SpellCode_ShamanLightningBolt, SpellCode_ShamanChainLightning, SpellCode_ShamanEarthShock, SpellCode_ShamanFlameShock, SpellCode_ShamanFrostShock}

			core.MakeProcTriggerAura(&shaman.Unit, core.ProcTrigger{
				Name:     "Stormcaller Spelldamage Bonus",
				Callback: core.CallbackOnSpellHitDealt,
				Outcome:  core.OutcomeLanded,
				Handler: func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if slices.Contains(affectedSpellCodes, spell.SpellCode) && sim.Proc(0.20, "Stormcaller's Wrath") {
						buffAura.Activate(sim)
					}
				},
			})
		},

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

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

		3: func(agent core.Agent) {

		},

		5: func(agent core.Agent) {

		},

		8: func(agent core.Agent) {

		},
	},
})

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

		2: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.OnSpellRegistered(func(spell *core.Spell) {
				if spell.Flags.Matches(SpellFlagTotem) {
					spell.Cost.Multiplier -= 12
				}
			})
		},

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

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

		8: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.RegisterAura(core.Aura{
				Label: "Lightning Shield",
				OnInit: func(_ *core.Aura, _ *core.Simulation) {
					for _, lsAura := range shaman.LightningShieldAuras {
						if lsAura == nil {
							return
						}

						oldOnGain := lsAura.OnGain
						lsAura.OnGain = func(aura *core.Aura, sim *core.Simulation) {
							oldOnGain(aura, sim)
							shaman.AddStatDynamic(sim, stats.MP5, 15)
						}

						oldOnExpire := lsAura.OnExpire
						lsAura.OnExpire = func(aura *core.Aura, sim *core.Simulation) {
							oldOnExpire(aura, sim)
							shaman.AddStatDynamic(sim, stats.MP5, -15)
						}
					}
				},
			})
		},
	},
})

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

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

		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)
			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: func(sim *core.Simulation, spell *core.Spell, _ *core.SpellResult) {
					procAura.Activate(sim)
				},
			})
		},

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

		3: func(agent core.Agent) {

		},

		5: func(agent core.Agent) {
			shaman := agent.(ShamanAgent).GetShaman()
			shaman.PseudoStats.SchoolBonusCritChance[stats.SchoolIndexNature] += 3 * core.SpellCritRatingPerCritChance
		},

		8: func(agent core.Agent) {

		},
	},
})

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.GetOrRegisterAura(core.Aura{
				Label:    "Shaman Shock Crit Bonus",
				ActionID: core.ActionID{SpellID: 22804},
				OnInit: 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.AddStats(stats.Stats{
				stats.AttackPower:       40,
				stats.RangedAttackPower: 40,
			})
		},
	},
})

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 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 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 WindfuryBuffAuraId = [WindfuryTotemRanks + 1]int32{0, 8514, 10607, 10611}

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
	ChainHeal            []*core.Spell
	ChainLightning       []*core.Spell
	EarthShield          *core.Spell
	EarthShock           []*core.Spell
	ElementalMastery     *core.Spell
	FireNovaTotem        []*core.Spell
	FlameShock           []*core.Spell
	FrostShock           []*core.Spell
	GraceOfAirTotem      []*core.Spell
	HealingStreamTotem   []*core.Spell
	HealingWave          []*core.Spell
	LesserHealingWave    []*core.Spell
	LightningBolt        []*core.Spell
	LightningShield      []*core.Spell
	LightningShieldProcs []*core.Spell // The damage component of lightning shield is a separate spell
	MagmaTotem           []*core.Spell
	ManaSpringTotem      []*core.Spell
	SearingTotem         []*core.Spell
	StoneskinTotem       []*core.Spell
	Stormstrike          *core.Spell
	StrengthOfEarthTotem []*core.Spell
	TremorTotem          *core.Spell
	WindfuryTotem        []*core.Spell
	WindfuryWeaponMH     *core.Spell
	WindfuryWeaponOH     *core.Spell
	WindwallTotem        []*core.Spell

	// Auras
	ClearcastingAura     *core.Aura
	LightningShieldAuras []*core.Aura

	// Totems
	ActiveTotems     [4]*core.Spell
	ActiveTotemBuffs [4]*core.Aura
	TotemExpirations [4]time.Duration // The expiration time of each totem (earth, air, fire, water).

	EarthTotems []*core.Spell
	FireTotems  []*core.Spell
	WaterTotems []*core.Spell
	AirTotems   []*core.Spell
	Totems      *proto.ShamanTotems

	WindfuryTotemPeriodicActions      []*core.PendingAction
	ActiveWindfuryTotemPeriodicAction *core.PendingAction

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

	ChainLightningBounceCoefficient float64
}

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) 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) *core.Aura

func (*Shaman) GetCharacter

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

func (*Shaman) Initialize

func (shaman *Shaman) Initialize()

func (*Shaman) NewAPLValue

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

func (*Shaman) RegisterFlametongueImbue

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

func (*Shaman) RegisterFrostbrandImbue

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

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)

type ShamanAgent

type ShamanAgent interface {
	core.Agent

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

Implemented by each Shaman spec.