common

package
v1.9.3 Latest Latest
Warning

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

 Go to latest Published: Mar 13, 2026 License: MIT Imports: 6 Imported by: 0

Documentation

Index

Constants

View Source 
const Unresolved = time.Duration(-1)

Variables

View Source 
var ItemSetBurningRage = core.NewItemSet(core.ItemSet{
	Name: "Burning Rage",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.MeleeHit, 20)
		},
	},
})
View Source 
var ItemSetDesolationBattlegear = core.NewItemSet(core.ItemSet{
	Name: "Desolation Battlegear",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.MeleeHit, 35)
		},
		4: func(agent core.Agent) {
			character := agent.GetCharacter()
			procAura := character.NewTemporaryStatsAura("Desolation Battlegear Proc", core.ActionID{SpellID: 37617}, stats.Stats{stats.AttackPower: 160, stats.RangedAttackPower: 160}, time.Second*15)

			icd := core.Cooldown{
				Timer:    character.NewTimer(),
				Duration: time.Second * 20,
			}
			const procChance = 0.01

			character.RegisterAura(core.Aura{
				Label:    "Desolation Battlegear",
				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, spellEffect *core.SpellEffect) {
					if !spellEffect.Landed() {
						return
					}
					if !spellEffect.ProcMask.Matches(core.ProcMaskMeleeOrRanged) {
						return
					}
					if !icd.IsReady(sim) {
						return
					}
					if sim.RandomFloat("Desolation Battlegear") > procChance {
						return
					}
					icd.Use(sim)
					procAura.Activate(sim)
				},
			})
		},
	},
})
View Source 
var ItemSetDoomplateBattlegear = core.NewItemSet(core.ItemSet{
	Name: "Doomplate Battlegear",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.MeleeHit, 35)
		},
		4: func(agent core.Agent) {
			character := agent.GetCharacter()
			procAura := character.NewTemporaryStatsAura("Doomplate Battlegear Proc", core.ActionID{SpellID: 37611}, stats.Stats{stats.AttackPower: 160, stats.RangedAttackPower: 160}, time.Second*15)

			const procChance = 0.02
			character.RegisterAura(core.Aura{
				Label:    "Doomplate Battlegear",
				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, spellEffect *core.SpellEffect) {
					if !spellEffect.Landed() {
						return
					}
					if !spellEffect.ProcMask.Matches(core.ProcMaskMeleeOrRanged) {
						return
					}
					if sim.RandomFloat("Doomplate Battlegear") > procChance {
						return
					}
					procAura.Activate(sim)
				},
			})
		},
	},
})
View Source 
var ItemSetEbonNetherscale = core.NewItemSet(core.ItemSet{
	Name: "Netherscale Armor",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.MeleeHit, 20)
		},
	},
})
View Source 
var ItemSetFaithInFelsteel = core.NewItemSet(core.ItemSet{
	Name: "Faith in Felsteel",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.Strength, 25)
		},
	},
})
View Source 
var ItemSetFelstalker = core.NewItemSet(core.ItemSet{
	Name: "Felstalker Armor",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.MeleeHit, 20)
		},
	},
})
View Source 
var ItemSetFistsOfFury = core.NewItemSet(core.ItemSet{
	Name: "The Fists of Fury",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			character := agent.GetCharacter()

			procSpell := character.RegisterSpell(core.SpellConfig{
				ActionID:    core.ActionID{SpellID: 41989},
				SpellSchool: core.SpellSchoolFire,
				ApplyEffects: core.ApplyEffectFuncDirectDamage(core.SpellEffect{
					ProcMask:         core.ProcMaskEmpty,
					DamageMultiplier: 1,
					ThreatMultiplier: 1,

					BaseDamage:     core.BaseDamageConfigRoll(100, 150),
					OutcomeApplier: character.OutcomeFuncMagicHitAndCrit(character.DefaultSpellCritMultiplier()),
				}),
			})

			ppmm := character.AutoAttacks.NewPPMManager(2, core.ProcMaskMelee)

			character.RegisterAura(core.Aura{
				Label:    "Fists of Fury",
				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, spellEffect *core.SpellEffect) {
					if !spellEffect.Landed() || !spellEffect.ProcMask.Matches(core.ProcMaskMelee) {
						return
					}
					if !ppmm.Proc(sim, spellEffect.ProcMask, "The Fists of Fury") {
						return
					}

					procSpell.Cast(sim, spellEffect.Target)
				},
			})
		},
	},
})
View Source 
var ItemSetFlameGuard = core.NewItemSet(core.ItemSet{
	Name: "Flame Guard",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.Parry, 20)
		},
	},
})
View Source 
var ItemSetManaEtched = core.NewItemSet(core.ItemSet{
	Name: "Mana-Etched Regalia",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.SpellHit, 35)
		},
		4: func(agent core.Agent) {
			character := agent.GetCharacter()
			procAura := character.NewTemporaryStatsAura("Mana-Etched Insight Proc", core.ActionID{SpellID: 37619}, stats.Stats{stats.SpellPower: 110}, time.Second*15)

			character.RegisterAura(core.Aura{
				Label:    "Mana-Etched Insight",
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					aura.Activate(sim)
				},
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if sim.RandomFloat("Mana-Etched Insight") > 0.02 {
						return
					}
					procAura.Activate(sim)
				},
			})
		},
	},
})
View Source 
var ItemSetNetherstrike = core.NewItemSet(core.ItemSet{
	Name: "Netherstrike Armor",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.SpellPower, 23)
		},
	},
})
View Source 
var ItemSetPrimalstrike = core.NewItemSet(core.ItemSet{
	Name: "Primal Intent",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.AttackPower, 40)
			agent.GetCharacter().AddStat(stats.RangedAttackPower, 40)
		},
	},
})
View Source 
var ItemSetSpellfire = core.NewItemSet(core.ItemSet{
	Name: "Wrath of Spellfire",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			character := agent.GetCharacter()
			character.AddStatDependency(stats.StatDependency{
				SourceStat:   stats.Intellect,
				ModifiedStat: stats.SpellPower,
				Modifier: func(intellect float64, spellPower float64) float64 {
					return spellPower + intellect*0.07
				},
			})
		},
	},
})
View Source 
var ItemSetSpellstrike = core.NewItemSet(core.ItemSet{
	Name: "Spellstrike Infusion",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			character := agent.GetCharacter()
			procAura := character.NewTemporaryStatsAura("Spellstrike Proc", core.ActionID{SpellID: 32106}, stats.Stats{stats.SpellPower: 92}, time.Second*10)

			character.RegisterAura(core.Aura{
				Label:    "Spellstrike",
				Duration: core.NeverExpires,
				OnReset: func(aura *core.Aura, sim *core.Simulation) {
					aura.Activate(sim)
				},
				OnCastComplete: func(aura *core.Aura, sim *core.Simulation, spell *core.Spell) {
					if sim.RandomFloat("spellstrike") > 0.05 {
						return
					}
					procAura.Activate(sim)
				},
			})
		},
	},
})
View Source 
var ItemSetStrengthOfTheClefthoof = core.NewItemSet(core.ItemSet{
	Name: "Strength of the Clefthoof",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.Strength, 20)
		},
	},
})
View Source 
var ItemSetTheTwinStars = core.NewItemSet(core.ItemSet{
	Name: "The Twin Stars",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.SpellPower, 15)
		},
	},
})
View Source 
var ItemSetTwinBladesOfAzzinoth = core.NewItemSet(core.ItemSet{
	Name: "The Twin Blades of Azzinoth",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			character := agent.GetCharacter()

			if character.CurrentTarget.MobType == proto.MobType_MobTypeDemon {
				character.PseudoStats.MobTypeAttackPower += 200
			}
			procAura := character.NewTemporaryStatsAura("Twin Blade of Azzinoth Proc", core.ActionID{SpellID: 41435}, stats.Stats{stats.MeleeHaste: 450}, time.Second*10)

			ppmm := character.AutoAttacks.NewPPMManager(1.0, core.ProcMaskMelee)
			icd := core.Cooldown{
				Timer:    character.NewTimer(),
				Duration: time.Second * 45,
			}

			character.RegisterAura(core.Aura{
				Label:    "Twin Blades of Azzinoth",
				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, spellEffect *core.SpellEffect) {
					if !spellEffect.Landed() {
						return
					}

					if !spellEffect.ProcMask.Matches(core.ProcMaskMelee) {
						return
					}

					if !icd.IsReady(sim) {
						return
					}

					if !ppmm.Proc(sim, spellEffect.ProcMask, "Twin Blades of Azzinoth") {
						return
					}
					icd.Use(sim)
					procAura.Activate(sim)
				},
			})
		},
	},
})
View Source 
var ItemSetWastewalkerArmor = core.NewItemSet(core.ItemSet{
	Name: "Wastewalker Armor",
	Bonuses: map[int32]core.ApplyEffect{
		2: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.MeleeHit, 35)
		},
		4: func(agent core.Agent) {
			character := agent.GetCharacter()
			procAura := character.NewTemporaryStatsAura("Wastewalker Armor Proc", core.ActionID{SpellID: 37618}, stats.Stats{stats.AttackPower: 160, stats.RangedAttackPower: 160}, time.Second*15)

			icd := core.Cooldown{
				Timer:    character.NewTimer(),
				Duration: time.Second * 20,
			}
			const procChance = 0.02

			character.RegisterAura(core.Aura{
				Label:    "Wastewalker Armor",
				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, spellEffect *core.SpellEffect) {
					if !spellEffect.Landed() {
						return
					}
					if !spellEffect.ProcMask.Matches(core.ProcMaskMeleeOrRanged) {
						return
					}
					if !icd.IsReady(sim) {
						return
					}
					if sim.RandomFloat("Wastewalker Armor") > procChance {
						return
					}
					icd.Use(sim)
					procAura.Activate(sim)
				},
			})
		},
	},
})
View Source 
var ItemSetWindhawk = core.NewItemSet(core.ItemSet{
	Name: "Windhawk Armor",
	Bonuses: map[int32]core.ApplyEffect{
		3: func(agent core.Agent) {
			agent.GetCharacter().AddStat(stats.MP5, 8)
		},
	},
})

Functions

func NewSimpleStatDefensiveTrinketEffect 

func NewSimpleStatDefensiveTrinketEffect(itemID int32, bonus stats.Stats, duration time.Duration, cooldown time.Duration)

func NewSimpleStatItemActiveEffect 

func NewSimpleStatItemActiveEffect(itemID int32, bonus stats.Stats, duration time.Duration, cooldown time.Duration, sharedCDFunc func(*core.Character) core.Cooldown)

func NewSimpleStatItemEffect 

func NewSimpleStatItemEffect(itemID int32, bonus stats.Stats, duration time.Duration, cooldown time.Duration)

No shared CD

func NewSimpleStatOffensiveTrinketEffect 

func NewSimpleStatOffensiveTrinketEffect(itemID int32, bonus stats.Stats, duration time.Duration, cooldown time.Duration)

Types

type AbilityCaster 

type AbilityCaster func(sim *core.Simulation) bool

Returns whether the cast was successful.

type GCDScheduler 

type GCDScheduler struct {
	// contains filtered or unexported fields
}

func (*GCDScheduler) DoNextAbility 

func (gs *GCDScheduler) DoNextAbility(sim *core.Simulation, character *core.Character) bool

Returns whether the cast was a success.

func (*GCDScheduler) Reset 

func (gs *GCDScheduler) Reset(sim *core.Simulation, character *core.Character)

func (*GCDScheduler) Schedule 

func (gs *GCDScheduler) Schedule(newAbility ScheduledAbility) time.Duration

Returns the actual time at which the ability will be cast.

func (*GCDScheduler) ScheduleGroup 

func (gs *GCDScheduler) ScheduleGroup(newAbilities []ScheduledAbility) time.Duration

Schedules a group of abilities that must be cast back-to-back. Most settings are taken from the first ability.

func (*GCDScheduler) ScheduleMCD 

func (gs *GCDScheduler) ScheduleMCD(character *core.Character, mcdID core.ActionID)

Takes ownership of a MCD, adding it to the schedule and removing it from the character's managed cooldowns.

type ManaSpendingRateTracker 

type ManaSpendingRateTracker struct {
	// contains filtered or unexported fields
}

Tracks how fast mana is being spent. This is used by some specs to decide whether to use more mana-efficient or higher-dps spells.

func NewManaSpendingRateTracker 

func NewManaSpendingRateTracker() ManaSpendingRateTracker

func (*ManaSpendingRateTracker) ManaSpentPerSecond 

func (tracker *ManaSpendingRateTracker) ManaSpentPerSecond(sim *core.Simulation, character *core.Character) float64

func (*ManaSpendingRateTracker) ProjectedManaCost 

func (tracker *ManaSpendingRateTracker) ProjectedManaCost(sim *core.Simulation, character *core.Character) float64

The amount of mana we will need to spend over the remaining sim duration at the current rate of mana spending.

func (*ManaSpendingRateTracker) ProjectedManaSurplus 

func (tracker *ManaSpendingRateTracker) ProjectedManaSurplus(sim *core.Simulation, character *core.Character) bool

func (*ManaSpendingRateTracker) ProjectedRemainingMana 

func (tracker *ManaSpendingRateTracker) ProjectedRemainingMana(sim *core.Simulation, character *core.Character) float64

func (*ManaSpendingRateTracker) Reset 

func (tracker *ManaSpendingRateTracker) Reset()

This needs to be called on sim reset.

func (*ManaSpendingRateTracker) Update 

func (tracker *ManaSpendingRateTracker) Update(sim *core.Simulation, character *core.Character)

This needs to be called at regular intervals to update the tracker's data.

type ScheduledAbility 

type ScheduledAbility struct {
	// When to cast this ability. Might not cast at this time if there are conflicts.
	DesiredCastAt time.Duration

	// Limits the search window for conflict resolution.
	MinCastAt time.Duration
	MaxCastAt time.Duration

	// Override the default conflict resolution behavior of searching after the
	// desired cast time first. Instead, search before the desired cast time first.
	PrioritizeEarlierForConflicts bool

	// How much GCD time will be used by this ability.
	Duration time.Duration

	// How to cast this ability.
	TryCast AbilityCaster
	// contains filtered or unexported fields
}

type WaitAction 

type WaitAction struct {
	// contains filtered or unexported fields
}

func NewWaitAction 

func NewWaitAction(sim *core.Simulation, unit *core.Unit, duration time.Duration, reason WaitReason) WaitAction

func (WaitAction) Cast 

func (action WaitAction) Cast(sim *core.Simulation) bool

func (WaitAction) GetActionID 

func (action WaitAction) GetActionID() core.ActionID

func (WaitAction) GetDuration 

func (action WaitAction) GetDuration() time.Duration

func (WaitAction) GetManaCost 

func (action WaitAction) GetManaCost() float64

func (WaitAction) GetName 

func (action WaitAction) GetName() string

func (WaitAction) GetTag 

func (action WaitAction) GetTag() int32

func (WaitAction) GetUnit 

func (action WaitAction) GetUnit() *core.Unit

type WaitReason 

type WaitReason byte
const (
	WaitReasonNone     WaitReason = iota // unknown why we waited
	WaitReasonOOM                        // no mana to cast
	WaitReasonRotation                   // waiting on rotation
	WaitReasonOptimal                    // waiting because its more optimal than casting.
)

Source Files

View all Source files

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.