warrior

package
v0.0.32 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 18, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	DiamondFlask        = 20130
	Exsanguinar         = 216497
	SuzerainDefender    = 224280
	GrileksCharmOFMight = 231286
	RageOfMugamba       = 231350
)
View Source 
const (
	SpellCode_WarriorNone int32 = iota

	SpellCode_WarriorBloodthirst
	SpellCode_WarriorDeepWounds
	SpellCode_WarriorDevastate
	SpellCode_WarriorExecute
	SpellCode_WarriorMortalStrike
	SpellCode_WarriorOverpower
	SpellCode_WarriorRagingBlow
	SpellCode_WarriorRend
	SpellCode_WarriorRevenge
	SpellCode_WarriorShieldSlam
	SpellCode_WarriorSlam
	SpellCode_WarriorSlamMH
	SpellCode_WarriorSlamOH
	SpellCode_WarriorStanceBattle
	SpellCode_WarriorStanceBerserker
	SpellCode_WarriorStanceGladiator
	SpellCode_WarriorStanceDefensive
	SpellCode_WarriorWhirlwind
	SpellCode_WarriorWhirlwindMH
	SpellCode_WarriorWhirlwindOH
)
View Source 
const (
	ArmsTree = 0
	FuryTree = 1
	ProtTree = 2
)
View Source 
const RevengeRanks = 6
View Source 
const ShoutExpirationThreshold = time.Second * 3
View Source 
const (
	SpellFlagOffensive = core.SpellFlagAgentReserved1
)

Variables

View Source 
var ItemSetBattlegearOfUnyieldingStrength = core.NewItemSet(core.ItemSet{
	Name: "Battlegear of Unyielding Strength",
	Bonuses: map[int32]core.ApplyEffect{

		3: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			if !warrior.HasRune(proto.WarriorRune_RuneShockwave) {
				return
			}

			warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - RAQ - Warrior - Tank 3P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					warrior.Shockwave.CD.Duration /= 2
				},
			})
		},
	},
})
View Source 
var ItemSetBattlegearOfValor = core.NewItemSet(core.ItemSet{
	Name: "Battlegear of Heroism",
	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) {
			c := agent.GetCharacter()
			actionID := core.ActionID{SpellID: 450587}
			healthMetrics := c.NewHealthMetrics(core.ActionID{SpellID: 450589})
			rageMetrics := c.NewRageMetrics(core.ActionID{SpellID: 450589})

			core.MakeProcTriggerAura(&c.Unit, core.ProcTrigger{
				ActionID: actionID,
				Name:     "S03 - Warrior Armor Heal Trigger - Battlegear of Valor",
				Callback: core.CallbackOnSpellHitDealt,
				Outcome:  core.OutcomeLanded,
				ProcMask: core.ProcMaskMelee,
				PPM:      1,
				Handler: func(sim *core.Simulation, spell *core.Spell, _ *core.SpellResult) {
					c.GainHealth(sim, sim.Roll(88, 132), healthMetrics)
					if c.HasRageBar() {
						c.AddRage(sim, 10, rageMetrics)
					}
				},
			})
		},

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

		8: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Armor, 200)
		},
	},
})
View Source 
var ItemSetChampionsBattlegear = core.NewItemSet(core.ItemSet{
	Name: "Champion's Battlegear",
	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) {

		},

		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 20)
		},
	},
})
View Source 
var ItemSetConquerorsAdvance = core.NewItemSet(core.ItemSet{
	Name: "Conqueror's Advance",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			if !warrior.Talents.DeathWish {
				return
			}

			warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - TAQ - Warrior - Damage 2P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					warrior.DeathWish.CD.Duration /= 2
				},
			})
		},

		4: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			if warrior.Talents.DeepWounds == 0 {
				return
			}

			buffAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 1214166},
				Label:    "Bloodythirsty",
				Duration: time.Second * 3,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					warrior.PseudoStats.DamageDealtMultiplier *= 1.10
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					warrior.PseudoStats.DamageDealtMultiplier /= 1.10
				},
			})

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - TAQ - Warrior - Damage 4P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if (spell.SpellCode == SpellCode_WarriorDeepWounds && warrior.Rend.Dot(result.Target).IsActive()) ||
						(spell.SpellCode == SpellCode_WarriorRend && warrior.DeepWounds.Dot(result.Target).IsActive()) {
						buffAura.Activate(sim)
					}
				},
				OnPeriodicDamageDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if (spell.SpellCode == SpellCode_WarriorDeepWounds && warrior.Rend.Dot(result.Target).IsActive()) ||
						(spell.SpellCode == SpellCode_WarriorRend && warrior.DeepWounds.Dot(result.Target).IsActive()) {
						buffAura.Activate(sim)
					}
				},
			}))
		},
	},
})
View Source 
var ItemSetConquerorsBulwark = core.NewItemSet(core.ItemSet{
	Name: "Conqueror's Bulwark",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()

			warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - TAQ - Warrior - Tank 2P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					warrior.ThunderClap.CD.Duration = 0
				},
			})
		},

		4: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			if !warrior.Talents.ShieldSlam {
				return
			}

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - TAQ - Warrior - Tank 4P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					warrior.ShieldSlam.ThreatMultiplier *= 2
				},
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellCode == SpellCode_WarriorShieldSlam && result.Outcome.Matches(core.OutcomeDodge|core.OutcomeParry|core.OutcomeBlock) {
						spell.CD.Reset()
					}
				},
			}))
		},
	},
})
View Source 
var ItemSetImmoveableMight = core.NewItemSet(core.ItemSet{
	Name: "Immoveable Might",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			character := agent.GetCharacter()
			character.AddStat(stats.BlockValue, 30)
		},

		4: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			warrior.AddDamageDealtRageBonus(1)
			warrior.AddDamageTakenRageBonus(1)
		},

		6: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T1 - Warrior - Tank 6P Bonus",
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					warrior.defensiveStanceThreatMultiplier *= 1.10
					warrior.gladiatorStanceDamageMultiplier *= 1.04
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					warrior.defensiveStanceThreatMultiplier /= 1.10
					warrior.gladiatorStanceDamageMultiplier /= 1.04
				},
			}))
		},
	},
})
View Source 
var ItemSetImmoveableWrath = core.NewItemSet(core.ItemSet{
	Name: "Immoveable Wrath",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()

			actionID := core.ActionID{SpellID: 468066}
			rageMetrics := warrior.NewRageMetrics(actionID)

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Warrior - Protection 2P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.ProcMask.Matches(core.ProcMaskMelee) && result.DidParry() {
						warrior.AddRage(sim, 10, rageMetrics)
					}
				},
				OnSpellHitTaken: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if result.DidParry() {
						warrior.AddRage(sim, 10, rageMetrics)
					}
				},
			}))
		},

		4: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()

			flurryAura := warrior.makeFlurryAura(5)

			warrior.makeFlurryConsumptionTrigger(flurryAura)

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Warrior - Protection 4P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellCode == SpellCode_WarriorRevenge {
						flurryAura.Activate(sim)
						flurryAura.SetStacks(sim, 3)
					}
				},
			}))
		},

		6: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()

			retaliate := warrior.RegisterSpell(AnyStance, core.SpellConfig{
				ActionID:    core.ActionID{SpellID: 468071},
				SpellSchool: core.SpellSchoolPhysical,
				DefenseType: core.DefenseTypeMelee,
				ProcMask:    core.ProcMaskMeleeMHSpecial,
				Flags:       core.SpellFlagMeleeMetrics | core.SpellFlagNoOnCastComplete | core.SpellFlagPassiveSpell,

				CritDamageBonus:  warrior.impale(),
				DamageMultiplier: 1,
				ThreatMultiplier: 1,
				BonusCoefficient: 1,

				ApplyEffects: func(sim *core.Simulation, target *core.Unit, spell *core.Spell) {
					spell.CalcAndDealDamage(sim, target, warrior.MHNormalizedWeaponDamage(sim, spell.MeleeAttackPower()), spell.OutcomeMeleeSpecialNoBlockDodgeParry)
				},
			})

			icds := warrior.NewEnemyICDArray(func(u *core.Unit) *core.Cooldown {
				return &core.Cooldown{
					Timer:    warrior.NewTimer(),
					Duration: time.Second * 30,
				}
			})

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Warrior - Protection 6P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if !spell.ProcMask.Matches(core.ProcMaskMelee) || !result.DidParry() {
						return
					}

					if icd := icds.Get(result.Target); icd.IsReady(sim) {
						retaliate.Cast(sim, result.Target)
						icd.Use(sim)
					}
				},
			}))
		},
	},
})
View Source 
var ItemSetLieutenantCommandersBattlegear = core.NewItemSet(core.ItemSet{
	Name: "Lieutenant Commander's Battlegear",
	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) {

		},

		6: func(agent core.Agent) {
			c := agent.GetCharacter()
			c.AddStat(stats.Stamina, 20)
		},
	},
})
View Source 
var ItemSetUnstoppableMight = core.NewItemSet(core.ItemSet{
	Name: "Unstoppable Might",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()

			var affectedSpells []*core.Spell
			tacticianAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 464241},
				Label:    "Tactician",
				Duration: time.Second * 10,
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range warrior.Spellbook {
						if spell.Cost != nil && spell.Cost.CostType() == core.CostTypeRage && !spell.Flags.Matches(core.SpellFlagHelpful) {
							affectedSpells = append(affectedSpells, spell)
						}
					}
				},
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range affectedSpells {
						spell.Cost.FlatModifier -= 10
					}
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range affectedSpells {
						spell.Cost.FlatModifier += 10
					}
				},
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if slices.Contains(affectedSpells, spell) {
						aura.Deactivate(sim)
					}
				},
			})

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T1 - Warrior - Damage 2P Bonus Trigger",
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if slices.Contains(StanceCodes, spell.SpellCode) {
						tacticianAura.Activate(sim)
					}
				},
			}))
		},

		4: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()

			duration := time.Second * 15

			battleStanceAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 457706},
				Label:    "Echoes of Battle Stance",
				Duration: duration,
			})
			defStanceAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 457699},
				Label:    "Echoes of Defensive Stance",
				Duration: duration,
			})
			berserkStanceAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 457708},
				Label:    "Echoes of Berserker Stance",
				Duration: duration,
			})
			gladStanceAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 457819},
				Label:    "Echoes of Gladiator Stance",
				Duration: duration,
			})

			warrior.newStanceOverrideExclusiveEffect(BattleStance, battleStanceAura)
			warrior.newStanceOverrideExclusiveEffect(DefensiveStance, defStanceAura)
			warrior.newStanceOverrideExclusiveEffect(BerserkerStance, berserkStanceAura)
			warrior.newStanceOverrideExclusiveEffect(AnyStance, gladStanceAura)

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T1 - Warrior - Damage 4P Bonus Trigger",
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if slices.Contains(StanceCodes, spell.SpellCode) {
						switch warrior.PreviousStance {
						case BattleStance:
							battleStanceAura.Activate(sim)
						case DefensiveStance:
							defStanceAura.Activate(sim)
						case BerserkerStance:
							berserkStanceAura.Activate(sim)
						case GladiatorStance:
							gladStanceAura.Activate(sim)
						}
					}
				},
			}))
		},

		6: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()

			duration := time.Second * 15

			battleAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 457816},
				Label:    "Battle Forecast",
				Duration: duration,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					warrior.PseudoStats.SchoolDamageDealtMultiplier[stats.SchoolIndexPhysical] *= 1.10
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					warrior.PseudoStats.SchoolDamageDealtMultiplier[stats.SchoolIndexPhysical] /= 1.10
				},
			})
			defenseAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 457814},
				Label:    "Defense Forecast",
				Duration: duration,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					warrior.PseudoStats.DamageTakenMultiplier *= 0.90
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					warrior.PseudoStats.DamageTakenMultiplier /= 0.90
				},
			})
			berserkAura := warrior.RegisterAura(core.Aura{
				ActionID: core.ActionID{SpellID: 457817},
				Label:    "Berserker Forecast",
				Duration: duration,
				OnGain: func(aura *core.Aura, sim *core.Simulation) {
					warrior.AddStatDynamic(sim, stats.MeleeCrit, 10*core.CritRatingPerCritChance)
				},
				OnExpire: func(aura *core.Aura, sim *core.Simulation) {
					warrior.AddStatDynamic(sim, stats.MeleeCrit, -10*core.CritRatingPerCritChance)
				},
			})

			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T1 - Warrior - Damage 6P Bonus Trigger",
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					switch spell.SpellCode {
					case SpellCode_WarriorStanceBattle:
						battleAura.Activate(sim)
					case SpellCode_WarriorStanceGladiator:
						battleAura.Activate(sim)
					case SpellCode_WarriorStanceDefensive:
						defenseAura.Activate(sim)
					case SpellCode_WarriorStanceBerserker:
						berserkAura.Activate(sim)
					}
				},
			}))
		},
	},
})
View Source 
var ItemSetUnstoppableWrath = core.NewItemSet(core.ItemSet{
	Name: "Unstoppable Wrath",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Warrior - Damage 2P Bonus",
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellCode == SpellCode_WarriorOverpower && result.DidCrit() {
						if dot := warrior.Rend.Dot(result.Target); dot.IsActive() {
							dot.Refresh(sim)
						}
					}
				},
			}))
		},

		4: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Warrior - Damage 4P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					warrior.HeroicStrike.DamageMultiplier *= 1.25
					warrior.Overpower.DamageMultiplier *= 1.25
					if warrior.SlamMH != nil {
						warrior.SlamMH.DamageMultiplier *= 1.25
					}
					if warrior.SlamOH != nil {
						warrior.SlamMH.DamageMultiplier *= 1.25
					}
					if warrior.QuickStrike != nil {
						warrior.QuickStrike.DamageMultiplier *= 1.25
					}
				},
			})
		},

		6: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			var affectedSpells []*WarriorSpell
			core.MakePermanent(warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Warrior - Damage 6P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					for _, spell := range []*WarriorSpell{warrior.Bloodthirst, warrior.MortalStrike, warrior.ShieldSlam} {
						if spell != nil {
							affectedSpells = append(affectedSpells, spell)
						}
					}
				},
				OnSpellHitDealt: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell, result *core.SpellResult) {
					if spell.SpellCode == SpellCode_WarriorSlamMH && result.Landed() {
						for _, spell := range affectedSpells {
							spell.CD.Reset()
						}
					}
				},
			}))
		},
	},
})
View Source 
var ItemSetVindicatorsBattlegear = core.NewItemSet(core.ItemSet{
	Name: "Vindicator's Battlegear",
	Bonuses: map[int32]core.ApplyEffect{

		2: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			warrior.AddStat(stats.Defense, 7)
		},

		3: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			if !warrior.Talents.ShieldSlam {
				return
			}

			warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - ZG - Warrior - Gladiator 3P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					warrior.ShieldSlam.CD.Duration -= time.Second * 2
				},
			})
		},

		5: func(agent core.Agent) {
			warrior := agent.(WarriorAgent).GetWarrior()
			if !warrior.HasRune(proto.WarriorRune_RuneGladiatorStance) {
				return
			}

			warrior.RegisterAura(core.Aura{
				Label: "S03 - Item - T2 - Warrior - Protection 6P Bonus",
				OnInit: func(aura *core.Aura, sim *core.Simulation) {
					idx := slices.IndexFunc(warrior.GladiatorStanceAura.ExclusiveEffects, func(ee *core.ExclusiveEffect) bool {
						return ee.Category.Name == stanceEffectCategory
					})
					ee := warrior.GladiatorStanceAura.ExclusiveEffects[idx]
					oldOnGain := ee.OnGain
					ee.OnGain = func(ee *core.ExclusiveEffect, sim *core.Simulation) {
						oldOnGain(ee, sim)
						warrior.Bloodrage.CD.Duration -= time.Second * 30
					}

					oldOnExpire := ee.OnExpire
					ee.OnExpire = func(ee *core.ExclusiveEffect, sim *core.Simulation) {
						oldOnExpire(ee, sim)
						warrior.Bloodrage.CD.Duration += time.Second * 30
					}
				},
			})
		},
	},
})
View Source 
var RevengeBaseDamage = [RevengeRanks + 1][]float64{{0, 0}, {12, 14}, {18, 22}, {25, 31}, {43, 53}, {64, 78}, {81, 99}}
View Source 
var RevengeLevel = [RevengeRanks + 1]int{0, 14, 24, 34, 44, 54, 60}
View Source 
var RevengeSpellId = [RevengeRanks + 1]int32{0, 6572, 6574, 7379, 11600, 11601, 25288}
View Source 
var StanceCodes = []int32{SpellCode_WarriorStanceBattle, SpellCode_WarriorStanceDefensive, SpellCode_WarriorStanceBerserker, SpellCode_WarriorStanceGladiator}
View Source 
var TalentTreeSizes = [3]int{18, 17, 17}

Functions

This section is empty.

Types

type Stance 

type Stance uint8
const (
	BattleStance Stance = 1 << iota
	DefensiveStance
	BerserkerStance
	GladiatorStance

	AnyStance = BattleStance | DefensiveStance | BerserkerStance | GladiatorStance
)

func (Stance) Matches added in v0.0.17 

func (stance Stance) Matches(other Stance) bool

type Warrior 

type Warrior struct {
	core.Character

	Talents *proto.WarriorTalents

	WarriorInputs

	// Current state
	Stance         Stance
	PreviousStance Stance // Used for Warrior T1 DPS 4P

	OverpowerAura *core.Aura

	BloodSurgeAura    *core.Aura
	RampageAura       *core.Aura
	SuddenDeathAura   *core.Aura
	TasteForBloodAura *core.Aura

	// Enrage Auras
	BerserkerRageAura      *core.Aura
	BloodrageAura          *core.Aura
	ConsumedByRageAura     *core.Aura
	EnrageAura             *core.Aura
	FreshMeatEnrageAura    *core.Aura
	WreckingCrewEnrageAura *core.Aura

	LastAMTick time.Duration

	BattleShout *WarriorSpell

	BattleStanceSpells    []*WarriorSpell
	DefensiveStanceSpells []*WarriorSpell
	BerserkerStanceSpells []*WarriorSpell

	Stances         []*WarriorSpell
	BattleStance    *WarriorSpell
	DefensiveStance *WarriorSpell
	BerserkerStance *WarriorSpell
	GladiatorStance *WarriorSpell

	Bloodrage         *WarriorSpell
	BerserkerRage     *WarriorSpell
	Bloodthirst       *WarriorSpell
	DeathWish         *WarriorSpell
	DemoralizingShout *WarriorSpell
	Execute           *WarriorSpell
	MortalStrike      *WarriorSpell
	Overpower         *WarriorSpell
	Rend              *WarriorSpell
	Revenge           *WarriorSpell
	ShieldBlock       *WarriorSpell
	ShieldSlam        *WarriorSpell
	Slam              *WarriorSpell
	SlamMH            *WarriorSpell
	SlamOH            *WarriorSpell
	SunderArmor       *WarriorSpell
	Devastate         *WarriorSpell
	ThunderClap       *WarriorSpell
	Whirlwind         *WarriorSpell
	WhirlwindMH       *WarriorSpell
	WhirlwindOH       *WarriorSpell
	DeepWounds        *WarriorSpell
	ConcussionBlow    *WarriorSpell
	RagingBlow        *WarriorSpell
	Hamstring         *WarriorSpell
	Rampage           *WarriorSpell
	Shockwave         *WarriorSpell

	HeroicStrike      *WarriorSpell
	HeroicStrikeQueue *WarriorSpell
	QuickStrike       *WarriorSpell
	Cleave            *WarriorSpell
	CleaveQueue       *WarriorSpell

	BattleStanceAura    *core.Aura
	DefensiveStanceAura *core.Aura
	BerserkerStanceAura *core.Aura
	GladiatorStanceAura *core.Aura

	ShieldBlockAura *core.Aura

	DemoralizingShoutAuras core.AuraArray
	SunderArmorAuras       core.AuraArray
	ThunderClapAuras       core.AuraArray
	// contains filtered or unexported fields
}

func NewWarrior 

func NewWarrior(character *core.Character, talents string, inputs WarriorInputs) *Warrior

func (*Warrior) AddPartyBuffs 

func (warrior *Warrior) AddPartyBuffs(_ *proto.PartyBuffs)

func (*Warrior) AddRaidBuffs 

func (warrior *Warrior) AddRaidBuffs(raidBuffs *proto.RaidBuffs)

func (*Warrior) ApplyRunes 

func (warrior *Warrior) ApplyRunes()

func (*Warrior) ApplyTalents 

func (warrior *Warrior) ApplyTalents()

func (*Warrior) GetCharacter 

func (warrior *Warrior) GetCharacter() *core.Character

func (*Warrior) HasRune 

func (warrior *Warrior) HasRune(rune proto.WarriorRune) bool

func (*Warrior) Initialize 

func (warrior *Warrior) Initialize()

func (*Warrior) IsEnraged added in v0.0.17 

func (warrior *Warrior) IsEnraged() bool

func (*Warrior) RegisterRecklessnessCD 

func (warrior *Warrior) RegisterRecklessnessCD()

Recklessness now increases critical strike chance by 50% (was 100%) and the duration is reduced to 12 seconds, but the cooldown is reduced to 5 minutes.

func (*Warrior) RegisterShieldBlockCD 

func (warrior *Warrior) RegisterShieldBlockCD()

func (*Warrior) RegisterShieldWallCD 

func (warrior *Warrior) RegisterShieldWallCD()

TODO: Classic Update

func (*Warrior) RegisterSpell added in v0.0.17 

func (warrior *Warrior) RegisterSpell(stanceMask Stance, config core.SpellConfig) *WarriorSpell

func (*Warrior) Reset 

func (warrior *Warrior) Reset(sim *core.Simulation)

func (*Warrior) StanceMatches 

func (warrior *Warrior) StanceMatches(other Stance) bool

func (*Warrior) ToughnessArmorMultiplier 

func (warrior *Warrior) ToughnessArmorMultiplier() float64

func (*Warrior) TryHSOrCleave 

func (warrior *Warrior) TryHSOrCleave(sim *core.Simulation, mhSwingSpell *core.Spell) *core.Spell

type WarriorAgent 

type WarriorAgent interface {
	GetWarrior() *Warrior
}

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

type WarriorInputs 

type WarriorInputs struct {
	StanceSnapshot bool
	Stance         proto.WarriorStance
}

type WarriorSpell added in v0.0.17 

type WarriorSpell struct {
	*core.Spell
	StanceMask Stance
	// contains filtered or unexported fields
}

func (*WarriorSpell) CanCast added in v0.0.17 

func (ws *WarriorSpell) CanCast(sim *core.Simulation, target *core.Unit) bool

func (*WarriorSpell) GetStanceMask added in v0.0.17 

func (ws *WarriorSpell) GetStanceMask() Stance

Returns the StanceMask accounting for a possible override

func (*WarriorSpell) IsEqual added in v0.0.17 

func (ws *WarriorSpell) IsEqual(s *core.Spell) bool

func (*WarriorSpell) IsReady added in v0.0.17 

func (ws *WarriorSpell) IsReady(sim *core.Simulation) bool

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.