mage

Documentation

Index

• Constants
• Variables
• func RegisterMage()
• type FrozenOrb
  • func (ffo *FrozenOrb) ExecuteCustomRotation(sim *core.Simulation)
  • func (ffo *FrozenOrb) GetPet() *core.Pet
  • func (ffo *FrozenOrb) Initialize()
  • func (ffo *FrozenOrb) Reset(_ *core.Simulation)
• type Mage
  • func NewMage(character *core.Character, options *proto.Player) *Mage
  • func (mage *Mage) AddPartyBuffs(partyBuffs *proto.PartyBuffs)
  • func (mage *Mage) AddRaidBuffs(raidBuffs *proto.RaidBuffs)
  • func (mage *Mage) ApplyRunes()
  • func (mage *Mage) ApplyTalents()
  • func (mage *Mage) GetCharacter() *core.Character
  • func (mage *Mage) GetMage() *Mage
  • func (mage *Mage) HasRune(rune proto.MageRune) bool
  • func (mage *Mage) Initialize()
  • func (mage *Mage) NewFrozenOrb() *FrozenOrb
  • func (mage *Mage) Reset(sim *core.Simulation)
• type MageAgent

Constants

const (
	SpellFlagMage       = core.SpellFlagAgentReserved1
	SpellFlagChillSpell = core.SpellFlagAgentReserved2
)

const (
	SpellCode_MageNone int32 = iota
	SpellCode_MageArcaneBarrage
	SpellCode_MageArcaneBlast
	SpellCode_MageArcaneExplosion
	SpellCode_MageArcaneMissiles
	SpellCode_MageArcaneSurge
	SpellCode_MageBalefireBolt
	SpellCode_MageFireball
	SpellCode_MageFireBlast
	SpellCode_MageFrostbolt
	SpellCode_MageFrostfireBolt
	SpellCode_MageFrozenOrb
	SpellCode_MageLivingBomb
	SpellCode_MageLivingBombExplosion
	SpellCode_MageLivingFlame
	SpellCode_MageScorch
	SpellCode_MageSpellfrostBolt
)

const ArcaneExplosionRanks = 6

const ArcaneMissilesRanks = 8

const BlastWaveRanks = 5

const BlizzardRanks = 6

const FireBlastRanks = 7

const (
	FireRuby = 20036
)

const FireballRanks = 12

const FlamestrikeRanks = 6

const FrostboltRanks = 11

const IgniteTicks = 2

If two spells proc Ignite at almost exactly the same time, the latter overwrites the former.

const ManaGemRanks = 4

Technically 4 different items

const PyroblastRanks = 8

const ScorchRanks = 7

Variables

var ArcaneExplosionBaseDamage = [ArcaneExplosionRanks + 1][]float64{{0}, {34, 38}, {58, 65}, {101, 110}, {140, 153}, {190, 207}, {249, 270}}

var ArcaneExplosionLevel = [ArcaneExplosionRanks + 1]int{0, 14, 22, 30, 38, 46, 54}

var ArcaneExplosionManaCost = [ArcaneExplosionRanks + 1]float64{0, 75, 120, 185, 250, 315, 390}

var ArcaneExplosionSpellCoeff = [ArcaneExplosionRanks + 1]float64{0, .111, .143, .143, .143, .143, .143}

var ArcaneExplosionSpellId = [ArcaneExplosionRanks + 1]int32{0, 1449, 8437, 8438, 8439, 10201, 10202}

var ArcaneMissilesBaseTickDamage = [ArcaneMissilesRanks + 1]float64{0, 26, 38, 57, 86, 115, 153, 196, 230}

var ArcaneMissilesCastTime = [ArcaneMissilesRanks + 1]int32{0, 3, 4, 5, 5, 5, 5, 5, 5}

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

var ArcaneMissilesManaCost = [ArcaneMissilesRanks + 1]float64{0, 85, 140, 235, 320, 410, 500, 595, 655}

var ArcaneMissilesSpellCoeff = [ArcaneMissilesRanks + 1]float64{0, .132, .204, .24, .24, .24, .24, .24, .24}

var ArcaneMissilesSpellId = [ArcaneMissilesRanks + 1]int32{0, 5143, 5144, 5145, 8416, 8417, 10211, 10212, 25345}

var BlastWaveBaseDamage = [BlastWaveRanks + 1][]float64{{0}, {160, 192}, {205, 246}, {285, 338}, {374, 443}, {462, 544}}

var BlastWaveLevel = [BlastWaveRanks + 1]int{0, 30, 36, 44, 52, 60}

var BlastWaveManaCost = [BlastWaveRanks + 1]float64{0, 215, 270, 355, 450, 545}

var BlastWaveSpellId = [BlastWaveRanks + 1]int32{0, 11113, 13018, 13019, 13020, 13021}

var BlizzardBaseDamage = [BlizzardRanks + 1]float64{0, 200, 352, 520, 720, 936, 1192}

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

var BlizzardManaCost = [BlizzardRanks + 1]float64{0, 320, 520, 720, 935, 1160, 1400}

var BlizzardSpellId = [BlizzardRanks + 1]int32{0, 10, 6141, 8427, 10185, 10186, 10187}

var FireBlastBaseDamage = [FireBlastRanks + 1][]float64{{0}, {27, 35}, {62, 76}, {107, 132}, {177, 211}, {246, 295}, {342, 405}, {446, 524}}

var FireBlastLevel = [FireBlastRanks + 1]int{0, 6, 14, 22, 30, 38, 46, 54}

var FireBlastManaCost = [FireBlastRanks + 1]float64{0, 40, 75, 115, 165, 220, 280, 340}

var FireBlastSpellCoeff = [FireBlastRanks + 1]float64{0, .204, .332, .429, .429, .429, .429, .429}

var FireBlastSpellId = [FireBlastRanks + 1]int32{0, 2136, 2137, 2138, 8412, 8413, 10197, 10199}

var FireballBaseDamage = [FireballRanks + 1][]float64{{0}, {16, 25}, {34, 49}, {57, 77}, {89, 122}, {140, 189}, {207, 274}, {264, 345}, {328, 425}, {398, 512}, {488, 623}, {561, 715}, {596, 760}}

var FireballCastTime = [FireballRanks + 1]int32{0, 1500, 2000, 2500, 3000, 3500, 3500, 3500, 3500, 3500, 3500, 3500, 3500}

var FireballDotDamage = [FireballRanks + 1]float64{0, 2, 3, 6, 12, 20, 28, 32, 40, 52, 60, 72, 76}

var FireballLevel = [FireballRanks + 1]int{0, 1, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 60}

var FireballManaCost = [FireballRanks + 1]float64{0, 30, 45, 65, 95, 140, 185, 220, 260, 305, 350, 395, 410}

var FireballSpellCoeff = [FireballRanks + 1]float64{0, .123, .271, .5, .793, 1, 1, 1, 1, 1, 1, 1, 1}

var FireballSpellId = [FireballRanks + 1]int32{0, 133, 143, 145, 3140, 8400, 8401, 8402, 10148, 10149, 10150, 10151, 25306}

var FlamestrikeBaseDamage = [FlamestrikeRanks + 1][]float64{{0}, {55, 71}, {96, 123}, {159, 197}, {220, 272}, {294, 362}, {381, 466}}

var FlamestrikeDotCoeff = [FlamestrikeRanks + 1]float64{0, .017, .02, .02, .02, .02, .02}

var FlamestrikeDotDamage = [FlamestrikeRanks + 1]float64{0, 48, 88, 140, 196, 264, 340}

var FlamestrikeLevel = [FlamestrikeRanks + 1]int{0, 16, 24, 32, 40, 48, 56}

var FlamestrikeManaCost = [FlamestrikeRanks + 1]float64{0, 195, 330, 490, 650, 815, 990}

var FlamestrikeSpellCoeff = [FlamestrikeRanks + 1]float64{0, .134, .157, .157, .157, .157, .157}

var FlamestrikeSpellId = [FlamestrikeRanks + 1]int32{0, 2120, 2121, 8422, 8423, 10215, 10216}

var FrostboltBaseDamage = [FrostboltRanks + 1][]float64{{0, 0}, {20, 22}, {33, 38}, {54, 61}, {78, 87}, {132, 144}, {180, 197}, {231, 251}, {301, 326}, {353, 383}, {440, 475}, {515, 555}}

var FrostboltCastTime = [FrostboltRanks + 1]int32{0, 1500, 1800, 2200, 2600, 3000, 3000, 3000, 3000, 3000, 3000, 3000}

var FrostboltLevel = [FrostboltRanks + 1]int{0, 4, 8, 14, 20, 26, 32, 38, 44, 50, 56, 60}

var FrostboltManaCost = [FrostboltRanks + 1]float64{0, 25, 35, 50, 65, 100, 130, 160, 195, 225, 260, 290}

var FrostboltSpellCoeff = [FrostboltRanks + 1]float64{0, .163, .269, .463, .706, .814, .814, .814, .814, .814, .814, .814}

var FrostboltSpellId = [FrostboltRanks + 1]int32{0, 116, 205, 837, 7322, 8406, 8407, 8408, 10179, 10180, 10181, 25304}

var ItemSetArcanistInsight = core.NewItemSet(core.ItemSet{
	Name: "Arcanist Insight",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {

		},

		4: func(agent core.Agent) {

			mage := agent.(MageAgent).GetMage()

			damageMultiplierPerSchool := 1.01
			auraDuration := time.Second * 15

			arcaneAura := mage.RegisterAura(core.Aura{
				Label:    "S03 - Item - T1 - Mage - Damage 4P Bonus (Arcane)",
				ActionID: core.ActionID{SpellID: 456398}.WithTag(int32(stats.SchoolIndexArcane)),
				Duration: auraDuration,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.DamageDealtMultiplier *= damageMultiplierPerSchool
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.DamageDealtMultiplier /= damageMultiplierPerSchool
				},
			})

			fireAura := mage.RegisterAura(core.Aura{
				Label:    "S03 - Item - T1 - Mage - Damage 4P Bonus (Fire)",
				ActionID: core.ActionID{SpellID: 456398}.WithTag(int32(stats.SchoolIndexFire)),
				Duration: auraDuration,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.DamageDealtMultiplier *= damageMultiplierPerSchool
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.DamageDealtMultiplier /= damageMultiplierPerSchool
				},
			})

			frostAura := mage.RegisterAura(core.Aura{
				Label:    "S03 - Item - T1 - Mage - Damage 4P Bonus (Frost)",
				ActionID: core.ActionID{SpellID: 456398}.WithTag(int32(stats.SchoolIndexFrost)),
				Duration: auraDuration,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.DamageDealtMultiplier *= damageMultiplierPerSchool
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.DamageDealtMultiplier /= damageMultiplierPerSchool
				},
			})

			core.MakePermanent(mage.RegisterAura(core.Aura{
				Label: "S03 - Item - T1 - Mage - Damage 4P Bonus",
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if spell.SpellSchool.Matches(core.SpellSchoolPhysical) {
						return
					}
					if spell.SpellSchool.Matches(core.SpellSchoolArcane) {
						arcaneAura.Activate(sim)
					}
					if spell.SpellSchool.Matches(core.SpellSchoolFire) {
						fireAura.Activate(sim)
					}
					if spell.SpellSchool.Matches(core.SpellSchoolFrost) {
						frostAura.Activate(sim)
					}
				},
			}))
		},

		6: func(agent core.Agent) {
			mage := agent.(MageAgent).GetMage()

			bonusFoFProcChance := .20
			bonusSpiritRegenRateCasting := .15
			bonusSpellPower := 18.0

			core.MakePermanent(mage.RegisterAura(core.Aura{
				Label:    "S03 - Item - T1 - Mage - Damage 6P Bonus",
				ActionID: core.ActionID{SpellID: 456402},
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					if mage.IceArmorAura != nil {
						mage.FingersOfFrostProcChance += bonusFoFProcChance
					} else if mage.MageArmorAura != nil {
						mage.PseudoStats.SpiritRegenRateCasting += bonusSpiritRegenRateCasting
					} else if mage.MoltenArmorAura != nil {
						mage.AddStatDynamic(sim, stats.SpellPower, bonusSpellPower)
					}
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					if mage.IceArmorAura != nil {
						mage.FingersOfFrostProcChance -= bonusFoFProcChance
					} else if mage.MageArmorAura != nil {
						mage.PseudoStats.SpiritRegenRateCasting += bonusSpiritRegenRateCasting
					} else if mage.MoltenArmorAura != nil {
						mage.AddStatDynamic(sim, stats.SpellPower, bonusSpellPower)
					}
				},
			}))
		},
	},
})

var ItemSetArcanistMoment = core.NewItemSet(core.ItemSet{
	Name: "Arcanist Moment",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {

		},

		4: func(agent core.Agent) {

		},

		6: func(agent core.Agent) {

		},
	},
})

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

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

		4: func(agent core.Agent) {

		},

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

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

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

		4: func(agent core.Agent) {

		},

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

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

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

		4: func(agent core.Agent) {
			c := agent.GetCharacter()
			actionID := core.ActionID{SpellID: 450527}
			manaMetrics := c.NewManaMetrics(actionID)

			core.MakeProcTriggerAura(&c.Unit, core.ProcTrigger{
				Name:       "S03 - Mana Proc on Cast - Magister's Regalia",
				Callback:   core.CallbackOnSpellHitDealt,
				Outcome:    core.OutcomeLanded,
				ProcMask:   core.ProcMaskSpellDamage | core.ProcMaskSpellHealing,
				ProcChance: 0.06,
				Handler: func(sim *core.Simulation, spell *core.Spell, _ *core.SpellResult) {
					if c.HasManaBar() {
						c.AddMana(sim, 300, manaMetrics)
					}
				},
			})
		},

		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 ManaGemItemId = [ManaGemRanks + 1]int32{0, 5514, 5513, 8007, 8008}

var ManaGemLevel = [ManaGemRanks + 1]int{0, 23, 38, 48, 58}

var ManaGemManaRestored = [ManaGemRanks + 1][]float64{{0, 0}, {375, 425}, {550, 650}, {775, 925}, {1000, 1200}}

var PyroblastBaseDamage = [PyroblastRanks + 1][]float64{{0}, {148, 195}, {184, 241}, {270, 343}, {341, 431}, {427, 536}, {510, 639}, {625, 776}, {716, 890}}

var PyroblastDotDamage = [PyroblastRanks + 1]float64{0, 56, 72, 96, 124, 156, 188, 228, 268}

var PyroblastLevel = [PyroblastRanks + 1]int{0, 20, 24, 30, 36, 42, 48, 54, 60}

var PyroblastManaCost = [PyroblastRanks + 1]float64{0, 125, 150, 195, 240, 285, 335, 385, 440}

var PyroblastSpellId = [PyroblastRanks + 1]int32{0, 11366, 12505, 12522, 12523, 12524, 12525, 12526, 18809}

var ScorchBaseDamage = [ScorchRanks + 1][]float64{{0}, {55, 68}, {81, 98}, {105, 126}, {133, 159}, {168, 199}, {207, 247}, {237, 280}}

var ScorchLevel = [ScorchRanks + 1]int{0, 22, 28, 34, 40, 46, 52, 58}

var ScorchManaCost = [ScorchRanks + 1]float64{0, 50, 65, 80, 100, 115, 135, 150}

var ScorchSpellId = [ScorchRanks + 1]int32{0, 2948, 8444, 8445, 8446, 10205, 10206, 10207}

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

Functions

func RegisterMage

func RegisterMage()

Types

type FrozenOrb

type FrozenOrb struct {
	core.Pet

	FrozenOrbTick          *core.Spell
	FrozenOrbFingerOfFrost *core.Aura
	TickCount              int64
	// contains filtered or unexported fields
}

func (*FrozenOrb) ExecuteCustomRotation

func (ffo *FrozenOrb) ExecuteCustomRotation(sim *core.Simulation)

func (*FrozenOrb) GetPet

func (ffo *FrozenOrb) GetPet() *core.Pet

func (*FrozenOrb) Initialize

func (ffo *FrozenOrb) Initialize()

func (*FrozenOrb) Reset

func (ffo *FrozenOrb) Reset(_ *core.Simulation)

type Mage

type Mage struct {
	core.Character

	Talents *proto.MageTalents
	Options *proto.Mage_Options

	ArcaneBarrage           *core.Spell
	ArcaneBlast             *core.Spell
	ArcaneExplosion         []*core.Spell
	ArcaneMissiles          []*core.Spell
	ArcaneMissilesTickSpell []*core.Spell
	ArcaneSurge             *core.Spell
	BalefireBolt            *core.Spell
	BlastWave               []*core.Spell
	Blizzard                []*core.Spell
	DeepFreeze              *core.Spell
	Fireball                []*core.Spell
	FireBlast               []*core.Spell
	Flamestrike             []*core.Spell
	Frostbolt               []*core.Spell
	FrostfireBolt           *core.Spell
	FrozenOrb               *core.Spell
	IceLance                *core.Spell
	Ignite                  *core.Spell
	LivingBomb              *core.Spell
	LivingFlame             *core.Spell
	ManaGem                 []*core.Spell
	Pyroblast               []*core.Spell
	Scorch                  []*core.Spell
	SpellfrostBolt          *core.Spell

	IcyVeins *core.Spell

	ArcaneBlastAura     *core.Aura
	ArcanePotencyAura   *core.Aura
	ArcanePowerAura     *core.Aura
	ClearcastingAura    *core.Aura
	CombustionAura      *core.Aura
	FingersOfFrostAura  *core.Aura
	HotStreakAura       *core.Aura
	IceArmorAura        *core.Aura
	ImprovedScorchAuras core.AuraArray
	MageArmorAura       *core.Aura
	MissileBarrageAura  *core.Aura
	MoltenArmorAura     *core.Aura

	FingersOfFrostProcChance float64
	// contains filtered or unexported fields
}

func NewMage

func NewMage(character *core.Character, options *proto.Player) *Mage

func (*Mage) AddPartyBuffs

func (mage *Mage) AddPartyBuffs(partyBuffs *proto.PartyBuffs)

func (*Mage) AddRaidBuffs

func (mage *Mage) AddRaidBuffs(raidBuffs *proto.RaidBuffs)

func (*Mage) ApplyRunes

func (mage *Mage) ApplyRunes()

func (*Mage) ApplyTalents

func (mage *Mage) ApplyTalents()

func (*Mage) GetCharacter

func (mage *Mage) GetCharacter() *core.Character

func (*Mage) GetMage

func (mage *Mage) GetMage() *Mage

func (*Mage) HasRune

func (mage *Mage) HasRune(rune proto.MageRune) bool

func (*Mage) Initialize

func (mage *Mage) Initialize()

func (*Mage) NewFrozenOrb

func (mage *Mage) NewFrozenOrb() *FrozenOrb

func (*Mage) Reset

func (mage *Mage) Reset(sim *core.Simulation)

type MageAgent

type MageAgent interface {
	GetMage() *Mage
}

Agent is a generic way to access underlying mage on any of the agents.