mage

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 IceBarrierLevel = [IceBarrierRanks + 1]int{0, 40, 46, 52, 58}

var IceBarrierManaCost = [IceBarrierRanks + 1]float64{0, 305, 360, 420, 480}

var IceBarrierSpellId = [IceBarrierRanks + 1]int32{0, 11426, 13031, 13032, 13033}

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

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

		5: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.SpellPenetration, 10)
		},

		8: func(agent core.Agent) {
			mage := agent.(MageAgent).GetMage()
			mage.RegisterAura(core.Aura{
				Label:    "Subtlety",
				ActionID: core.ActionID{SpellID: 23545},
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.ThreatMultiplier /= 1.15
				},
			})
		},
	},
})

var ItemSetChampionsArcanum = core.NewItemSet(core.ItemSet{
	Name: "Champion's Arcanum",
	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 ItemSetEnigmaVestments = core.NewItemSet(core.ItemSet{
	Name: "Enigma Vestments",
	Bonuses: map[int32]core.ApplyEffect{

		3: func(agent core.Agent) {

		},

		5: func(agent core.Agent) {
			mage := agent.(MageAgent).GetMage()
			actionID := core.ActionID{SpellID: 26129}

			enigmasAnswerAura := mage.RegisterAura(core.Aura{
				Label:     "Enigma's Answer",
				ActionID:  actionID,
				Duration:  time.Second * 20,
				MaxStacks: 4,
				OnStacksChange: func(aura *core.Aura, sim *core.Simulation, oldStacks, newStacks int32) {
					mage.AddStatDynamic(sim, stats.SpellHit, float64(-5*oldStacks))
					mage.AddStatDynamic(sim, stats.SpellHit, float64(5*newStacks))
				},
			})

			mage.RegisterAura(core.Aura{
				Label:    "Enigma Resist 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 result.Outcome.Matches(core.OutcomeMiss) && spell.ProcMask.Matches(core.ProcMaskDirect) {
						enigmasAnswerAura.Activate(sim)
						enigmasAnswerAura.AddStack(sim)
					}
				},
			})
		},
	},
})

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

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

		4: func(agent core.Agent) {

		},

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

var ItemSetFrostfireRegalia = core.NewItemSet(core.ItemSet{
	Name: "Frostfire Regalia",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			mage := agent.(MageAgent).GetMage()
			mage.RegisterAura(core.Aura{
				Label: "Evocation (Frostfire Regalia)",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					if mage.Evocation != nil {
						mage.Evocation.CD.Duration -= time.Second * 60
					}
				},
			})
		},

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

			fireWardingAura := mage.RegisterAura(core.Aura{
				Label:    "Fire Resistance",
				ActionID: core.ActionID{SpellID: 28765},
				Duration: time.Second * 30,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.FireResistance, 35)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.FireResistance, -35)
				},
			})

			frostWardingAura := mage.RegisterAura(core.Aura{
				Label:    "Frost Resistance",
				ActionID: core.ActionID{SpellID: 28766},
				Duration: time.Second * 30,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.FrostResistance, 35)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.FrostResistance, -35)
				},
			})

			natureWardingAura := mage.RegisterAura(core.Aura{
				Label:    "Nature Resistance",
				ActionID: core.ActionID{SpellID: 28768},
				Duration: time.Second * 30,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.NatureResistance, 35)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.NatureResistance, -35)
				},
			})

			shadowWardingAura := mage.RegisterAura(core.Aura{
				Label:    "Shadow Resistance",
				ActionID: core.ActionID{SpellID: 28769},
				Duration: time.Second * 30,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.ShadowResistance, 35)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.ShadowResistance, -35)
				},
			})

			arcaneWardingAura := mage.RegisterAura(core.Aura{
				Label:    "Arcane Resistance",
				ActionID: core.ActionID{SpellID: 28770},
				Duration: time.Second * 30,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.ArcaneResistance, 35)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.AddStatDynamic(sim, stats.ArcaneResistance, -35)
				},
			})

			mage.RegisterAura(core.Aura{
				Label:    "Adaptive Warding",
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					aura.Activate(sim)
				},
				OnSpellHitTaken: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if sim.Proc(0.20, "Adaptive Warding") {
						if spell.SpellSchool.Matches(core.SpellSchoolFire) {
							fireWardingAura.Activate(sim)
							return
						}
						if spell.SpellSchool.Matches(core.SpellSchoolFrost) {
							frostWardingAura.Activate(sim)
							return
						}
						if spell.SpellSchool.Matches(core.SpellSchoolNature) {
							natureWardingAura.Activate(sim)
							return
						}
						if spell.SpellSchool.Matches(core.SpellSchoolShadow) {
							shadowWardingAura.Activate(sim)
							return
						}
						if spell.SpellSchool.Matches(core.SpellSchoolArcane) {
							arcaneWardingAura.Activate(sim)
							return
						}
					}
				},
			})
		},

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

			procAuras := mage.NewEnemyAuraArray(func(target *core.Unit) *core.Aura {
				return target.GetOrRegisterAura(core.Aura{
					Label:     "Elemental Vulnerability",
					ActionID:  core.ActionID{SpellID: 28772},
					Duration:  time.Second * 30,
					MaxStacks: 1,

					OnGain: func(aura *core.Aura, sim *core.Simulation) {
						aura.SetStacks(sim, aura.MaxStacks)

						for si := stats.SchoolIndexArcane; si < stats.SchoolLen; si++ {
							aura.Unit.PseudoStats.SchoolBonusDamageTaken[si] += 200
						}
					},
					OnExpire: func(aura *core.Aura, sim *core.Simulation) {
						for si := stats.SchoolIndexArcane; si < stats.SchoolLen; si++ {
							aura.Unit.PseudoStats.SchoolBonusDamageTaken[si] -= 200
						}
					},
					OnSpellHitTaken: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {

						if aura.RemainingDuration(sim) == aura.Duration {
							return
						}

						if result.Landed() && spell.ProcMask.Matches(core.ProcMaskDirect) {
							aura.RemoveStack(sim)
						}
					},
				})
			})

			handler := func(sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
				procAuras.Get(result.Target).Activate(sim)
			}

			core.MakeProcTriggerAura(&mage.Unit, core.ProcTrigger{
				ActionID:   core.ActionID{SpellID: 28771},
				Name:       "Elemental Vulnerability",
				Callback:   core.CallbackOnSpellHitDealt,
				Outcome:    core.OutcomeLanded,
				ProcMask:   core.ProcMaskSpellDamage,
				ProcChance: 0.2,
				Handler:    handler,
			})
		},

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

			notThereAura := mage.RegisterAura(core.Aura{
				Label:    "Not There",
				ActionID: core.ActionID{SpellID: 28762},
				Duration: time.Second * 8,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.ThreatMultiplier -= 1
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					mage.PseudoStats.ThreatMultiplier += 1
				},
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {

					if aura.RemainingDuration(sim) == aura.Duration {
						return
					}
					aura.Deactivate(sim)
				},
			})

			mage.RegisterAura(core.Aura{
				Label:    "NotThere",
				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 sim.Proc(0.15, "Not There") && result.Landed() && spell.ProcMask.Matches(core.ProcMaskDirect) {
						notThereAura.Activate(sim)
					}
				},
			})
		},
	},
})

var ItemSetIllusionistsAttire = core.NewItemSet(core.ItemSet{
	Name: "Illusionist's Attire",
	Bonuses: map[int32]core.ApplyEffect{

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

		3: func(agent core.Agent) {

		},

		5: func(agent core.Agent) {
			mage := agent.(MageAgent).GetMage()
			mage.RegisterAura(core.Aura{
				Label:    "Improved Flamestrike",
				ActionID: core.ActionID{SpellID: 24491},
				Duration: core.NeverExpires,
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range mage.Spellbook {
						if spell.SpellCode == SpellCode_MageFlamestrike {
							spell.DefaultCast.CastTime -= time.Millisecond * 500
							spell.DefaultCast.GCD -= time.Millisecond * 500
						}
					}
				},
			})
		},
	},
})

var ItemSetLieutenantCommandersArcanum = core.NewItemSet(core.ItemSet{
	Name: "Lieutenant Commander's Arcanum",
	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 ItemSetNetherwindRegalia = core.NewItemSet(core.ItemSet{
	Name: "Netherwind Regalia",
	Bonuses: map[int32]core.ApplyEffect{

		3: func(agent core.Agent) {
			mage := agent.(MageAgent).GetMage()
			mage.RegisterAura(core.Aura{
				Label: "Friendly Nukes",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range mage.Spellbook {
						if spell.SpellCode == SpellCode_MageFireball || spell.SpellCode == SpellCode_MageArcaneMissilesTick {
							spell.FlatThreatBonus -= 20
						}
						if spell.SpellCode == SpellCode_MageScorch || spell.SpellCode == SpellCode_MageFrostbolt {
							spell.FlatThreatBonus -= 100
						}
					}
				},
			})
		},

		5: func(agent core.Agent) {

		},

		8: func(agent core.Agent) {
			mage := agent.(MageAgent).GetMage()
			actionID := core.ActionID{SpellID: 22008}

			affectedSpells := []*core.Spell{}
			netherwindFocusAura := mage.RegisterAura(core.Aura{
				Label:    "Netherwind Focus",
				ActionID: actionID,
				Duration: time.Second * 10,
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					for spellIdx := range mage.Spellbook {
						if spell := mage.Spellbook[spellIdx]; spell.DefaultCast.CastTime > 0 && spell.DefaultCast.CastTime <= 10*time.Second {
							affectedSpells = append(affectedSpells, spell)
						}
					}
				},
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					core.Each(affectedSpells, func(spell *core.Spell) {
						spell.CastTimeMultiplier -= 1
					})
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					core.Each(affectedSpells, func(spell *core.Spell) {
						spell.CastTimeMultiplier += 1
					})
				},
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if !slices.Contains(affectedSpells, spell) {
						return
					}
					if spell.CurCast.CastTime > 0 {
						return
					}
					aura.Deactivate(sim)
				},
			})

			mage.RegisterAura(core.Aura{
				Label:    "Netherwind Focus - Proc Aura",
				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_MageArcaneMissiles || spell.SpellCode == SpellCode_MageFireball || spell.SpellCode == SpellCode_MageFrostbolt {
						if sim.Proc(0.10, "Netherwind Focus Proc") {
							netherwindFocusAura.Activate(sim)
						}
					}
				},
			})
		},
	},
})

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

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

		4: func(agent core.Agent) {

		},

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

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

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

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

		4: func(agent core.Agent) {

		},

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

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}