core

package

Go to main page

Versions in this module

v0

v0.0.11

May 25, 2024

v0.0.10

May 17, 2024

v0.0.9

May 13, 2024

Changes in this version

+ func GetRageConversion(attacker_level int32) float64

v0.0.8

May 5, 2024

Changes in this version

type BuffName

+ const CommandingShout

+ const DevotionAura

+ const FireResistanceAura

+ const FireResistanceTotem

+ const ScrollOfProtection

+ const ShadowResistanceAura

v0.0.7

Apr 26, 2024

Changes in this version

+ const JudgementAuraTag

+ type APLValueEnergyThreshold struct

+ func (value *APLValueEnergyThreshold) GetBool(_ *Simulation) bool

+ func (value *APLValueEnergyThreshold) String() string

+ func (value *APLValueEnergyThreshold) Type() proto.APLValueType

type SpellResult

+ func (result *SpellResult) RawDamage() float64

v0.0.6

Apr 21, 2024

Changes in this version

type Spell

+ func (spell *Spell) DotOrAOEDot(target *Unit) *Dot

+ func (spell *Spell) TagSplitMetric(splitIdx int32, tag int32)

v0.0.5

Apr 14, 2024

Changes in this version

+ type APLActionAddComboPoints struct

+ func (action *APLActionAddComboPoints) Execute(sim *Simulation)

+ func (action *APLActionAddComboPoints) IsReady(sim *Simulation) bool

+ func (action *APLActionAddComboPoints) String() string

+ func (impl APLActionAddComboPoints) Finalize(*APLRotation)

+ func (impl APLActionAddComboPoints) GetAPLValues() []APLValue

+ func (impl APLActionAddComboPoints) GetInnerActions() []*APLAction

+ func (impl APLActionAddComboPoints) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionAddComboPoints) Reset(*Simulation)

type Aura

+ func JudgementOfTheCrusaderAura(caster *Unit, target *Unit, level int32, mult float64, extraBonus float64) *Aura

v0.0.4

Apr 8, 2024

Changes in this version

+ func ExternalIsbCaster(debuffs *proto.Debuffs, target *Unit)

+ type APLRune struct

+ type APLValueRuneIsEquipped struct

+ func (value *APLValueRuneIsEquipped) GetBool(sim *Simulation) bool

+ func (value *APLValueRuneIsEquipped) String() string

+ func (value *APLValueRuneIsEquipped) Type() proto.APLValueType

type Character

+ ActiveShapeShift *Aura

+ IsbConfig IsbConfig

+ func (character *Character) CancelShapeshift(sim *Simulation)

+ func (character *Character) IsShapeshifted() bool

+ func (character *Character) SetShapeshift(aura *Aura)

type Dot

+ BonusCoefficient float64

+ func (dot *Dot) Snapshot(target *Unit, baseDamage float64, isRollover bool)

+ func (dot *Dot) SnapshotHeal(target *Unit, baseHealing float64, isRollover bool)

type DotConfig

+ BonusCoefficient float64

+ type IsbConfig struct

type Item

+ ClassAllowlist []proto.Class

type Spell

+ BonusCoefficient float64

+ func (spell *Spell) BonusDamage() float64

type SpellConfig

+ BonusCoefficient float64

type Unit

+ func (unit *Unit) GetSchoolBonusDamageTaken(spell *Spell) float64

v0.0.3

Apr 1, 2024

Changes in this version

+ var DefaultTargetProtoLvl50 = &proto.Target

+ var FullBuffsPhase3 = BuffsCombo

+ var FullDebuffsPhase3 = &proto.Debuffs

+ var FullIndividualBuffsPhase3 = &proto.IndividualBuffs

+ var FullRaidBuffsPhase3 = &proto.RaidBuffs

+ func ApplyAtalAiProc(character *Character, atalAi proto.AtalAi)

+ type APLActionActivateAuraWithStacks struct

+ func (action *APLActionActivateAuraWithStacks) Execute(sim *Simulation)

+ func (action *APLActionActivateAuraWithStacks) IsReady(sim *Simulation) bool

+ func (action *APLActionActivateAuraWithStacks) String() string

+ func (impl APLActionActivateAuraWithStacks) Finalize(*APLRotation)

+ func (impl APLActionActivateAuraWithStacks) GetAPLValues() []APLValue

+ func (impl APLActionActivateAuraWithStacks) GetInnerActions() []*APLAction

+ func (impl APLActionActivateAuraWithStacks) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionActivateAuraWithStacks) Reset(*Simulation)

+ type APLValueAuraIsKnown struct

+ func (value *APLValueAuraIsKnown) GetBool(sim *Simulation) bool

+ func (value *APLValueAuraIsKnown) String() string

+ func (value *APLValueAuraIsKnown) Type() proto.APLValueType

+ type APLValueSpellIsKnown struct

+ func (value *APLValueSpellIsKnown) GetBool(sim *Simulation) bool

+ func (value *APLValueSpellIsKnown) String() string

+ func (value *APLValueSpellIsKnown) Type() proto.APLValueType

type AttackTable

+ BaseCritChance float64

+ DamageDoneByCasterMultiplier func(spell *Spell, attackTable *AttackTable) float64

type Aura

+ func BattleSquawkAura(character *Unit, stackcount int32) *Aura

+ func SerpentsStrikerFistDebuffAura(target *Unit, playerLevel int32) *Aura

type BuffName

+ const BattleSquawk

type Character

+ func (character *Character) GetFiftyPercentHasteBuffCD() *Timer

type Dot

+ func (dot *Dot) OutcomeTickSnapshotCritCounted(sim *Simulation, result *SpellResult, attackTable *AttackTable)

type Item

+ RequiresLevel int32

type ItemFilter

+ Level int32

type Spell

+ Rank int

+ RequiredLevel int

type SpellSchool

+ func (schoolMask SpellSchool) GetBaseIndices() []stats.SchoolIndex

type Unit

+ func (unit *Unit) GetResistanceForSchool(schoolIndex stats.SchoolIndex) float64

+ func (unit *Unit) GetSchoolCritTakenChance(spell *Spell) float64

v0.0.2

Mar 26, 2024

v0.0.1

Mar 24, 2024

Changes in this version

type AttackTable

+ CritMultiplier float64

type Spell

+ CritDamageBonus float64

+ DefenseType DefenseType

type SpellConfig

+ CritDamageBonus float64

+ DefenseType DefenseType

v0.0.0

Mar 22, 2024

Changes in this version

+ const ArmorPenPerPercentArmor

+ const AverageMagicPartialResistPerLevelMultiplier

+ const BaseFocusPerTick

+ const BattleShoutRanks

+ const BleedEffectCategory

+ const BlockRatingPerBlockChance

+ const BloodlustAuraTag

+ const BloodlustCD

+ const BloodlustDuration

+ const CharacterBuildPhaseAll

+ const CharacterMaxLevel

+ const CooldownPriorityBloodlust

+ const CooldownPriorityDefault

+ const CooldownPriorityDrums

+ const CooldownPriorityLow

+ const CritRatingPerCritChance

+ const DTPSReferenceStat

+ const DefaultAttackPowerPerDPS

+ const DefenseRatingPerDefense

+ const DefenseRatingToChanceReduction

+ const DemoralizingShoutRanks

+ const Diminish_Cd_Druid

+ const Diminish_Cd_Nondruid

+ const Diminish_Cm

+ const Diminish_Cp

+ const Diminish_kCd_Druid

+ const Diminish_kCd_Nondruid

+ const Diminish_kCm_Druid

+ const Diminish_kCm_Nondruid

+ const Diminish_kCp

+ const Diminish_k_Druid

+ const Diminish_k_Nondruid

+ const DivineGuardianCD

+ const DivineGuardianDuration

+ const DodgeRatingPerDodgeChance

+ const EnemyAutoAttackAPCoefficient

+ const EnergyPerTick

+ const EnergyTickDuration

+ const ExpertisePerQuarterPercentReduction

+ const GCDDefault

+ const GCDMin

+ const GuardianSpiritCD

+ const GuardianSpiritDuration

+ const HandOfSacrificeCD

+ const HandOfSacrificeDuration

+ const HasteRatingPerHastePercent

+ const HuntersMarkAuraTag

+ const Inactive

+ const InnervateCD

+ const InnervateDuration

+ const ItemIDAtieshMage

+ const ItemIDAtieshWarlock

+ const ItemIDBraidedEterniumChain

+ const ItemIDChainOfTheTwilightOwl

+ const ItemIDEyeOfTheNight

+ const ItemIDJadePendantOfBlasting

+ const ItemIDTheLightningCapacitor

+ const LongDuration

+ const ManaTideTotemCD

+ const ManaTideTotemDuration

+ const MaxFocus

+ const MaxRage

+ const MeleeHitRatingPerHitChance

+ const MissDodgeParryBlockCritChancePerDefense

+ const NeverExpires

+ const OutcomeLanded

+ const OutcomePartial

+ const PainSuppressionCD

+ const PainSuppressionDuration

+ const ParryRatingPerParryChance

+ const PowerInfusionCD

+ const PowerInfusionDuration

+ const ProcMaskDirect

+ const ProcMaskMelee

+ const ProcMaskMeleeMH

+ const ProcMaskMeleeOH

+ const ProcMaskMeleeOrProc

+ const ProcMaskMeleeOrRanged

+ const ProcMaskMeleeOrRangedSpecial

+ const ProcMaskMeleeSpecial

+ const ProcMaskMeleeWhiteHit

+ const ProcMaskRanged

+ const ProcMaskSpecial

+ const ProcMaskSpellOrProc

+ const ProcMaskWhiteHit

+ const ReplenishmentAuraDuration

+ const ResilienceRatingPerCritDamageReductionPercent

+ const ResilienceRatingPerCritReductionChance

+ const SatedAuraLabel

+ const ShatteringThrowCD

+ const ShortDuration

+ const SpellBatchWindow

+ const SpellCritEffectCategory

+ const SpellCritRatingPerCritChance

+ const SpellFirePowerEffectCategory

+ const SpellHitRatingPerHitChance

+ const SpellSchoolArcane

+ const SpellSchoolAstral

+ const SpellSchoolAttack

+ const SpellSchoolDivine

+ const SpellSchoolElemental

+ const SpellSchoolFire

+ const SpellSchoolFlamestrike

+ const SpellSchoolFrost

+ const SpellSchoolFrostfire

+ const SpellSchoolFroststorm

+ const SpellSchoolFroststrike

+ const SpellSchoolHoly

+ const SpellSchoolHolyfrost

+ const SpellSchoolHolystorm

+ const SpellSchoolHolystrike

+ const SpellSchoolMagic

+ const SpellSchoolNature

+ const SpellSchoolNone

+ const SpellSchoolPhysical

+ const SpellSchoolPlague

+ const SpellSchoolRadiant

+ const SpellSchoolShadow

+ const SpellSchoolShadowflame

+ const SpellSchoolShadowfrost

+ const SpellSchoolShadowstrike

+ const SpellSchoolSpellFrost

+ const SpellSchoolSpellShadow

+ const SpellSchoolSpellfire

+ const SpellSchoolSpellstrike

+ const SpellSchoolStormstrike

+ const SpellSchoolTwilight

+ const SpellSchoolVolcanic

+ const ThreatPerManaGained

+ const ThreatPerRageGained

+ const TricksOfTheTradeCD

+ const UnholyFrenzyCD

+ const UnholyFrenzyDuration

+ const WindfuryRanks

+ var AddEffectsToTest = true

+ var AverageDefaultSimTestOptions = &proto.SimOptions

+ var BaseStats = map[BaseStatsKey]stats.Stats

+ var BattleShoutBaseAP = [BattleShoutRanks + 1]float64

+ var BattleShoutLevel = [BattleShoutRanks + 1]int

+ var BattleShoutSpellId = [BattleShoutRanks + 1]int32

+ var BloodlustActionID = ActionID

+ var BuffSpellByLevel = map[BuffName]map[int32]stats.Stats

+ var ChanceOfDeathAuraLabel = "Chance of Death"

+ var ClassBaseCrit = map[proto.Class]stats.Stats

+ var ClassBaseStats = map[proto.Class]map[int]stats.Stats

+ var CritPerAgiAtLevel = map[proto.Class]map[int]float64

+ var CritPerIntAtLevel = map[proto.Class]map[int]float64

+ var DefaultSimTestOptions = &proto.SimOptions

+ var DefaultTargetProtoLvl25 = &proto.Target

+ var DefaultTargetProtoLvl40 = &proto.Target

+ var DemoralizingShoutBaseAP = [DemoralizingShoutRanks + 1]float64

+ var DemoralizingShoutLevel = [DemoralizingShoutRanks + 1]int

+ var DemoralizingShoutSpellId = [DemoralizingShoutRanks + 1]int32

+ var DenseDynamiteActionID = ActionID

+ var DivineGuardianAuraTag = "DivineGuardian"

+ var DodgePerAgiAtLevel = map[proto.Class]map[int32]float64

+ var EnchantsByEffectID = map[int32]Enchant

+ var EzThroRadiationBombActionID = ActionID

+ var FullBuffsPhase1 = BuffsCombo

+ var FullBuffsPhase2 = BuffsCombo

+ var FullDebuffsPhase1 = &proto.Debuffs

+ var FullDebuffsPhase2 = &proto.Debuffs

+ var FullIndividualBuffsPhase1 = &proto.IndividualBuffs

+ var FullIndividualBuffsPhase2 = &proto.IndividualBuffs

+ var FullPartyBuffs = &proto.PartyBuffs

+ var FullRaidBuffsPhase1 = &proto.RaidBuffs

+ var FullRaidBuffsPhase2 = &proto.RaidBuffs

+ var GoblinLandMineActionID = ActionID

+ var GuardianSpiritAuraTag = "GuardianSpirit"

+ var HandOfSacrificeAuraTag = "HandOfSacrifice"

+ var HighYieldRadiationBombActionID = ActionID

+ var InnervateAuraTag = "Innervate"

+ var ItemsByID = map[int32]Item

+ var JudgementOfLightAuraLabel = "Judgement of Light"

+ var JudgementOfWisdomAuraLabel = "Judgement of Wisdom"

+ var LevelToBuffRank = map[BuffName]map[int32]int32

+ var LevelToDebuffRank = map[DebuffName]map[int32]int32

+ var ManaTideTotemActionID = ActionID

+ var ManaTideTotemAuraTag = "ManaTideTotem"

+ var PainSuppressionAuraTag = "PainSuppression"

+ var PowerInfusionActionID = ActionID

+ var PowerInfusionAuraTag = "PowerInfusion"

+ var PresetEncounters []*proto.PresetEncounter

+ var RaceOffsets = map[proto.Race]stats.Stats

+ var RandomSuffixesByID = map[int32]RandomSuffix

+ var SapperActionID = ActionID

+ var SolidDynamiteActionID = ActionID

+ var StatWeightsDefaultSimTestOptions = &proto.SimOptions

+ var ThoriumGrenadeActionID = ActionID

+ var TricksOfTheTradeAuraTag = "TricksOfTheTrade"

+ var UnholyFrenzyAuraTag = "UnholyFrenzy"

+ var WITH_DB = false

+ var WindfuryBuffBonusAP = [WindfuryRanks + 1]float64

+ var WindfuryBuffLevelToRank = []int32

+ var WindfuryBuffSpellId = [WindfuryRanks + 1]int32

+ func APLRotationFromJsonString(jsonString string) *proto.APLRotation

+ func AddPresetEncounter(name string, targetPaths []string)

+ func AddPresetTarget(newPreset *PresetTarget)

+ func AddWeaponEffect(id int32, weaponEffect ApplyWeaponEffect)

+ func ApplyFixedUptimeAura(aura *Aura, uptime float64, tickLength time.Duration, startTime time.Duration)

+ func ApplyInspiration(character *Character, uptime float64)

+ func ApplyPetConsumeEffects(pet *Character, ownerConsumes *proto.Consumes)

+ func ApplyProcTriggerCallback(unit *Unit, aura *Aura, config ProcTrigger)

+ func BlessingOfSanctuaryAura(character *Character)

+ func BothTimersReady(t1 *Timer, t2 *Timer, sim *Simulation) bool

+ func BothTimersReadyAt(t1 *Timer, t2 *Timer) time.Duration

+ func BulkSim(ctx context.Context, request *proto.BulkSimRequest, ...) *proto.BulkSimResult

+ func CharacterStatsTest(label string, t *testing.T, raid *proto.Raid, expectedStats stats.Stats)

+ func ComputeStats(csr *proto.ComputeStatsRequest) *proto.ComputeStatsResult

+ func DurationFromSeconds(numSeconds float64) time.Duration

+ func Each[T any](src []T, f func(T))

+ func EquipmentSpecFromJsonString(jsonString string) *proto.EquipmentSpec

+ func FillTalentsProto(data protoreflect.Message, talentsStr string, treeSizes [3]int)

+ func FilterMap[K comparable, V any](src map[K]V, f func(K, V) bool) map[K]V

+ func FilterSlice[T any](src []T, f func(T) bool) []T

+ func Flatten[T any](src [][]T) []T

+ func GetPrimaryTalentTreeIndex(talentStr string) uint8

+ func GetSchoolResistanceStats(schoolIndex stats.SchoolIndex) []stats.Stat

+ func GetTristateValueFloat(effect proto.TristateEffect, regularValue float64, impValue float64) float64

+ func GetTristateValueInt32(effect proto.TristateEffect, regularValue int32, impValue int32) int32

+ func GetWeaponSkill(unit *Unit, weapon *Item) float64

+ func HasEnchantEffect(id int32) bool

+ func HasItemEffect(id int32) bool

+ func HasItemEffectForTest(id int32) bool

+ func HasWeaponEffect(id int32) bool

+ func InnervateManaThreshold(character *Character) float64

+ func ItemTypeToSlot(it proto.ItemType) proto.ItemSlot

+ func MakeSingleTargetEncounter(playerLevel int32, variation float64) *proto.Encounter

+ func MakeTristateValue(hasRegular bool, hasImproved bool) proto.TristateEffect

+ func MapMap[KI comparable, VI any, KO comparable, VO any](src map[KI]VI, f func(KI, VI) (KO, VO)) map[KO]VO

+ func MapSlice[I any, O any](src []I, f func(I) O) []O

+ func MaxTimeToReady(t1 *Timer, t2 *Timer, sim *Simulation) time.Duration

+ func ModNonMeleeAttackTable(table *AttackTable, attacker *Unit, defender *Unit, weapon *Item)

+ func MultiSchoolShouldUseArmor(schoolIndex stats.SchoolIndex, target *Unit) bool

+ func NewDefaultTarget(playerLevel int32) *proto.Target

+ func NewEnchantEffect(id int32, enchantEffect ApplyEffect)

+ func NewItemEffect(id int32, itemEffect ApplyEffect)

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

+ func NewSimpleStatItemActiveEffect(itemID int32, bonus stats.Stats, duration time.Duration, ...)

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

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

+ func NewSimpleStatOffensiveTrinketEffectWithOtherEffects(itemID int32, bonus stats.Stats, duration time.Duration, ...)

+ func PlayerProtoToSpec(player *proto.Player) proto.Spec

+ func RaidBenchmark(b *testing.B, rsr *proto.RaidSimRequest)

+ func RaidPlayersWithClass(raid *proto.Raid, class proto.Class) []*proto.Player

+ func RaidSimTest(label string, t *testing.T, rsr *proto.RaidSimRequest, expectedDps float64)

+ func RegisterAgentFactory(emptyOptions interface{}, spec proto.Spec, factory AgentFactory, ...)

+ func RegisterTemporaryStatsOnUseCD(character *Character, auraLabel string, tempStats stats.Stats, ...)

+ func RunBulkSim(request *proto.BulkSimRequest) *proto.BulkSimResult

+ func RunBulkSimAsync(ctx context.Context, request *proto.BulkSimRequest, ...)

+ func RunRaidSim(request *proto.RaidSimRequest) *proto.RaidSimResult

+ func RunRaidSimAsync(request *proto.RaidSimRequest, progress chan *proto.ProgressMetrics)

+ func RunSim(rsr *proto.RaidSimRequest, progress chan *proto.ProgressMetrics) *proto.RaidSimResult

+ func RunTestSuite(t *testing.T, suiteName string, generators []TestGenerator)

+ func ScheduledMajorArmorAura(aura *Aura, options PeriodicActionOptions, raid *proto.Raid)

+ func SinglePlayerRaidProto(player *proto.Player, partyBuffs *proto.PartyBuffs, raidBuffs *proto.RaidBuffs, ...) *proto.Raid

+ func StatWeights(request *proto.StatWeightsRequest) *proto.StatWeightsResult

+ func StatWeightsAsync(request *proto.StatWeightsRequest, progress chan *proto.ProgressMetrics)

+ func StatWeightsTest(label string, t *testing.T, _swr *proto.StatWeightsRequest, ...)

+ func TernaryDuration(condition bool, val1 time.Duration, val2 time.Duration) time.Duration

+ func TernaryFloat64(condition bool, val1 float64, val2 float64) float64

+ func TernaryInt(condition bool, val1 int, val2 int) int

+ func TernaryInt32(condition bool, val1 int32, val2 int32) int32

+ func Ternary[T any](condition bool, val1 T, val2 T) T

+ func UnitLevelFloat64(unitLevel int32, maxLevelPlus0Val float64, maxLevelPlus1Val float64, ...) float64

+ func WithSpec(player *proto.Player, spec interface{}) *proto.Player

+ func WithinToleranceFloat64(expectedValue float64, actualValue float64, tolerance float64) bool

+ type AIFactory func() TargetAI

+ type APLAction struct

+ func (action *APLAction) Execute(sim *Simulation)

+ func (action *APLAction) Finalize(rot *APLRotation)

+ func (action *APLAction) GetAllAPLValues() []APLValue

+ func (action *APLAction) GetAllActions() []*APLAction

+ func (action *APLAction) GetAllSpells() []*Spell

+ func (action *APLAction) IsReady(sim *Simulation) bool

+ func (action *APLAction) String() string

+ type APLActionActivateAura struct

+ func (action *APLActionActivateAura) Execute(sim *Simulation)

+ func (action *APLActionActivateAura) IsReady(sim *Simulation) bool

+ func (action *APLActionActivateAura) String() string

+ func (impl APLActionActivateAura) Finalize(*APLRotation)

+ func (impl APLActionActivateAura) GetAPLValues() []APLValue

+ func (impl APLActionActivateAura) GetInnerActions() []*APLAction

+ func (impl APLActionActivateAura) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionActivateAura) Reset(*Simulation)

+ type APLActionAutocastOtherCooldowns struct

+ func (action *APLActionAutocastOtherCooldowns) Execute(sim *Simulation)

+ func (action *APLActionAutocastOtherCooldowns) IsReady(sim *Simulation) bool

+ func (action *APLActionAutocastOtherCooldowns) Reset(*Simulation)

+ func (action *APLActionAutocastOtherCooldowns) String() string

+ func (impl APLActionAutocastOtherCooldowns) Finalize(*APLRotation)

+ func (impl APLActionAutocastOtherCooldowns) GetAPLValues() []APLValue

+ func (impl APLActionAutocastOtherCooldowns) GetInnerActions() []*APLAction

+ func (impl APLActionAutocastOtherCooldowns) GetNextAction(*Simulation) *APLAction

+ type APLActionCancelAura struct

+ func (action *APLActionCancelAura) Execute(sim *Simulation)

+ func (action *APLActionCancelAura) IsReady(sim *Simulation) bool

+ func (action *APLActionCancelAura) String() string

+ func (impl APLActionCancelAura) Finalize(*APLRotation)

+ func (impl APLActionCancelAura) GetAPLValues() []APLValue

+ func (impl APLActionCancelAura) GetInnerActions() []*APLAction

+ func (impl APLActionCancelAura) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionCancelAura) Reset(*Simulation)

+ type APLActionCastSpell struct

+ func (action *APLActionCastSpell) Execute(sim *Simulation)

+ func (action *APLActionCastSpell) IsReady(sim *Simulation) bool

+ func (action *APLActionCastSpell) String() string

+ func (impl APLActionCastSpell) Finalize(*APLRotation)

+ func (impl APLActionCastSpell) GetAPLValues() []APLValue

+ func (impl APLActionCastSpell) GetInnerActions() []*APLAction

+ func (impl APLActionCastSpell) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionCastSpell) Reset(*Simulation)

+ type APLActionChangeTarget struct

+ func (action *APLActionChangeTarget) Execute(sim *Simulation)

+ func (action *APLActionChangeTarget) IsReady(sim *Simulation) bool

+ func (action *APLActionChangeTarget) String() string

+ func (impl APLActionChangeTarget) Finalize(*APLRotation)

+ func (impl APLActionChangeTarget) GetAPLValues() []APLValue

+ func (impl APLActionChangeTarget) GetInnerActions() []*APLAction

+ func (impl APLActionChangeTarget) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionChangeTarget) Reset(*Simulation)

+ type APLActionChannelSpell struct

+ func (action *APLActionChannelSpell) Execute(sim *Simulation)

+ func (action *APLActionChannelSpell) GetAPLValues() []APLValue

+ func (action *APLActionChannelSpell) IsReady(sim *Simulation) bool

+ func (action *APLActionChannelSpell) String() string

+ func (impl APLActionChannelSpell) Finalize(*APLRotation)

+ func (impl APLActionChannelSpell) GetInnerActions() []*APLAction

+ func (impl APLActionChannelSpell) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionChannelSpell) Reset(*Simulation)

+ type APLActionCustomRotation struct

+ func (action *APLActionCustomRotation) Execute(sim *Simulation)

+ func (action *APLActionCustomRotation) IsReady(sim *Simulation) bool

+ func (action *APLActionCustomRotation) Reset(sim *Simulation)

+ func (action *APLActionCustomRotation) String() string

+ func (impl APLActionCustomRotation) Finalize(*APLRotation)

+ func (impl APLActionCustomRotation) GetAPLValues() []APLValue

+ func (impl APLActionCustomRotation) GetInnerActions() []*APLAction

+ func (impl APLActionCustomRotation) GetNextAction(*Simulation) *APLAction

+ type APLActionImpl interface

+ Execute func(*Simulation)

+ Finalize func(*APLRotation)

+ GetAPLValues func() []APLValue

+ GetInnerActions func() []*APLAction

+ GetNextAction func(sim *Simulation) *APLAction

+ IsReady func(*Simulation) bool

+ Reset func(*Simulation)

+ String func() string

+ type APLActionItemSwap struct

+ func (action *APLActionItemSwap) Execute(sim *Simulation)

+ func (action *APLActionItemSwap) IsReady(sim *Simulation) bool

+ func (action *APLActionItemSwap) String() string

+ func (impl APLActionItemSwap) Finalize(*APLRotation)

+ func (impl APLActionItemSwap) GetAPLValues() []APLValue

+ func (impl APLActionItemSwap) GetInnerActions() []*APLAction

+ func (impl APLActionItemSwap) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionItemSwap) Reset(*Simulation)

+ type APLActionMove struct

+ func (action *APLActionMove) Execute(sim *Simulation)

+ func (action *APLActionMove) IsReady(sim *Simulation) bool

+ func (action *APLActionMove) String() string

+ func (impl APLActionMove) Finalize(*APLRotation)

+ func (impl APLActionMove) GetAPLValues() []APLValue

+ func (impl APLActionMove) GetInnerActions() []*APLAction

+ func (impl APLActionMove) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionMove) Reset(*Simulation)

+ type APLActionMultidot struct

+ func (action *APLActionMultidot) Execute(sim *Simulation)

+ func (action *APLActionMultidot) GetAPLValues() []APLValue

+ func (action *APLActionMultidot) IsReady(sim *Simulation) bool

+ func (action *APLActionMultidot) Reset(*Simulation)

+ func (action *APLActionMultidot) String() string

+ func (impl APLActionMultidot) Finalize(*APLRotation)

+ func (impl APLActionMultidot) GetInnerActions() []*APLAction

+ func (impl APLActionMultidot) GetNextAction(*Simulation) *APLAction

+ type APLActionMultishield struct

+ func (action *APLActionMultishield) Execute(sim *Simulation)

+ func (action *APLActionMultishield) GetAPLValues() []APLValue

+ func (action *APLActionMultishield) IsReady(sim *Simulation) bool

+ func (action *APLActionMultishield) Reset(*Simulation)

+ func (action *APLActionMultishield) String() string

+ func (impl APLActionMultishield) Finalize(*APLRotation)

+ func (impl APLActionMultishield) GetInnerActions() []*APLAction

+ func (impl APLActionMultishield) GetNextAction(*Simulation) *APLAction

+ type APLActionResetSequence struct

+ func (action *APLActionResetSequence) Execute(sim *Simulation)

+ func (action *APLActionResetSequence) Finalize(rot *APLRotation)

+ func (action *APLActionResetSequence) IsReady(sim *Simulation) bool

+ func (action *APLActionResetSequence) String() string

+ func (impl APLActionResetSequence) GetAPLValues() []APLValue

+ func (impl APLActionResetSequence) GetInnerActions() []*APLAction

+ func (impl APLActionResetSequence) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionResetSequence) Reset(*Simulation)

+ type APLActionSchedule struct

+ func (action *APLActionSchedule) Execute(sim *Simulation)

+ func (action *APLActionSchedule) GetInnerActions() []*APLAction

+ func (action *APLActionSchedule) IsReady(sim *Simulation) bool

+ func (action *APLActionSchedule) Reset(*Simulation)

+ func (action *APLActionSchedule) String() string

+ func (impl APLActionSchedule) Finalize(*APLRotation)

+ func (impl APLActionSchedule) GetAPLValues() []APLValue

+ func (impl APLActionSchedule) GetNextAction(*Simulation) *APLAction

+ type APLActionSequence struct

+ func (action *APLActionSequence) Execute(sim *Simulation)

+ func (action *APLActionSequence) Finalize(rot *APLRotation)

+ func (action *APLActionSequence) GetInnerActions() []*APLAction

+ func (action *APLActionSequence) IsReady(sim *Simulation) bool

+ func (action *APLActionSequence) Reset(*Simulation)

+ func (action *APLActionSequence) String() string

+ func (impl APLActionSequence) GetAPLValues() []APLValue

+ func (impl APLActionSequence) GetNextAction(*Simulation) *APLAction

+ type APLActionStrictSequence struct

+ func (action *APLActionStrictSequence) Execute(sim *Simulation)

+ func (action *APLActionStrictSequence) Finalize(rot *APLRotation)

+ func (action *APLActionStrictSequence) GetInnerActions() []*APLAction

+ func (action *APLActionStrictSequence) GetNextAction(sim *Simulation) *APLAction

+ func (action *APLActionStrictSequence) IsReady(sim *Simulation) bool

+ func (action *APLActionStrictSequence) Reset(*Simulation)

+ func (action *APLActionStrictSequence) String() string

+ func (impl APLActionStrictSequence) GetAPLValues() []APLValue

+ type APLActionTriggerICD struct

+ func (action *APLActionTriggerICD) Execute(sim *Simulation)

+ func (action *APLActionTriggerICD) IsReady(sim *Simulation) bool

+ func (action *APLActionTriggerICD) String() string

+ func (impl APLActionTriggerICD) Finalize(*APLRotation)

+ func (impl APLActionTriggerICD) GetAPLValues() []APLValue

+ func (impl APLActionTriggerICD) GetInnerActions() []*APLAction

+ func (impl APLActionTriggerICD) GetNextAction(*Simulation) *APLAction

+ func (impl APLActionTriggerICD) Reset(*Simulation)

+ type APLActionWait struct

+ func (action *APLActionWait) Execute(sim *Simulation)

+ func (action *APLActionWait) GetAPLValues() []APLValue

+ func (action *APLActionWait) GetNextAction(sim *Simulation) *APLAction

+ func (action *APLActionWait) IsReady(sim *Simulation) bool

+ func (action *APLActionWait) String() string

+ func (impl APLActionWait) Finalize(*APLRotation)

+ func (impl APLActionWait) GetInnerActions() []*APLAction

+ func (impl APLActionWait) Reset(*Simulation)

+ type APLActionWaitUntil struct

+ func (action *APLActionWaitUntil) Execute(sim *Simulation)

+ func (action *APLActionWaitUntil) GetAPLValues() []APLValue

+ func (action *APLActionWaitUntil) GetNextAction(sim *Simulation) *APLAction

+ func (action *APLActionWaitUntil) IsReady(sim *Simulation) bool

+ func (action *APLActionWaitUntil) String() string

+ func (impl APLActionWaitUntil) Finalize(*APLRotation)

+ func (impl APLActionWaitUntil) GetInnerActions() []*APLAction

+ func (impl APLActionWaitUntil) Reset(*Simulation)

+ type APLRotation struct

+ func (apl *APLRotation) DoNextAction(sim *Simulation)

+ func (rot *APLRotation) GetAPLAura(sourceUnit UnitReference, auraId *proto.ActionID) AuraReference

+ func (rot *APLRotation) GetAPLDot(targetUnit UnitReference, spellId *proto.ActionID) *Dot

+ func (rot *APLRotation) GetAPLICDAura(sourceUnit UnitReference, auraId *proto.ActionID) AuraReference

+ func (rot *APLRotation) GetAPLMultidotSpell(spellId *proto.ActionID) *Spell

+ func (rot *APLRotation) GetAPLMultishieldSpell(spellId *proto.ActionID) *Spell

+ func (rot *APLRotation) GetAPLSpell(spellId *proto.ActionID) *Spell

+ func (rot *APLRotation) GetSourceUnit(ref *proto.UnitReference) UnitReference

+ func (rot *APLRotation) GetTargetUnit(ref *proto.UnitReference) UnitReference

+ func (rot *APLRotation) ValidationWarning(message string, vals ...interface{})

+ type APLValue interface

+ Finalize func(*APLRotation)

+ GetBool func(*Simulation) bool

+ GetDuration func(*Simulation) time.Duration

+ GetFloat func(*Simulation) float64

+ GetInnerValues func() []APLValue

+ GetInt func(*Simulation) int32

+ GetString func(*Simulation) string

+ String func() string

+ Type func() proto.APLValueType

+ type APLValueAnd struct

+ func (value *APLValueAnd) GetBool(sim *Simulation) bool

+ func (value *APLValueAnd) GetInnerValues() []APLValue

+ func (value *APLValueAnd) String() string

+ func (value *APLValueAnd) Type() proto.APLValueType

+ type APLValueAuraICDIsReadyWithReactionTime struct

+ func (value *APLValueAuraICDIsReadyWithReactionTime) GetBool(sim *Simulation) bool

+ func (value *APLValueAuraICDIsReadyWithReactionTime) String() string

+ func (value *APLValueAuraICDIsReadyWithReactionTime) Type() proto.APLValueType

+ type APLValueAuraInternalCooldown struct

+ func (value *APLValueAuraInternalCooldown) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueAuraInternalCooldown) String() string

+ func (value *APLValueAuraInternalCooldown) Type() proto.APLValueType

+ type APLValueAuraIsActive struct

+ func (value *APLValueAuraIsActive) GetBool(sim *Simulation) bool

+ func (value *APLValueAuraIsActive) String() string

+ func (value *APLValueAuraIsActive) Type() proto.APLValueType

+ type APLValueAuraIsActiveWithReactionTime struct

+ func (value *APLValueAuraIsActiveWithReactionTime) GetBool(sim *Simulation) bool

+ func (value *APLValueAuraIsActiveWithReactionTime) String() string

+ func (value *APLValueAuraIsActiveWithReactionTime) Type() proto.APLValueType

+ type APLValueAuraNumStacks struct

+ func (value *APLValueAuraNumStacks) GetInt(sim *Simulation) int32

+ func (value *APLValueAuraNumStacks) String() string

+ func (value *APLValueAuraNumStacks) Type() proto.APLValueType

+ type APLValueAuraRemainingTime struct

+ func (value *APLValueAuraRemainingTime) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueAuraRemainingTime) String() string

+ func (value *APLValueAuraRemainingTime) Type() proto.APLValueType

+ type APLValueAuraShouldRefresh struct

+ func (value *APLValueAuraShouldRefresh) GetBool(sim *Simulation) bool

+ func (value *APLValueAuraShouldRefresh) GetInnerValues() []APLValue

+ func (value *APLValueAuraShouldRefresh) String() string

+ func (value *APLValueAuraShouldRefresh) Type() proto.APLValueType

+ type APLValueAutoSwingTime struct

+ func (value *APLValueAutoSwingTime) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueAutoSwingTime) String() string

+ func (value *APLValueAutoSwingTime) Type() proto.APLValueType

+ type APLValueAutoTimeToNext struct

+ func (value *APLValueAutoTimeToNext) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueAutoTimeToNext) String() string

+ func (value *APLValueAutoTimeToNext) Type() proto.APLValueType

+ type APLValueChannelClipDelay struct

+ func (value *APLValueChannelClipDelay) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueChannelClipDelay) String() string

+ func (value *APLValueChannelClipDelay) Type() proto.APLValueType

+ type APLValueCoerced struct

+ func (value *APLValueCoerced) GetBool(sim *Simulation) bool

+ func (value *APLValueCoerced) GetInnerValues() []APLValue

+ func (value *APLValueCoerced) String() string

+ func (value *APLValueCoerced) Type() proto.APLValueType

+ func (value APLValueCoerced) GetDuration(sim *Simulation) time.Duration

+ func (value APLValueCoerced) GetFloat(sim *Simulation) float64

+ func (value APLValueCoerced) GetInt(sim *Simulation) int32

+ func (value APLValueCoerced) GetString(sim *Simulation) string

+ type APLValueCompare struct

+ func (value *APLValueCompare) GetBool(sim *Simulation) bool

+ func (value *APLValueCompare) GetInnerValues() []APLValue

+ func (value *APLValueCompare) String() string

+ func (value *APLValueCompare) Type() proto.APLValueType

+ type APLValueConst struct

+ func (value *APLValueConst) GetBool(_ *Simulation) bool

+ func (value *APLValueConst) GetDuration(_ *Simulation) time.Duration

+ func (value *APLValueConst) GetFloat(_ *Simulation) float64

+ func (value *APLValueConst) GetInt(_ *Simulation) int32

+ func (value *APLValueConst) GetString(_ *Simulation) string

+ func (value *APLValueConst) String() string

+ func (value *APLValueConst) Type() proto.APLValueType

+ type APLValueCurrentComboPoints struct

+ func (value *APLValueCurrentComboPoints) GetInt(sim *Simulation) int32

+ func (value *APLValueCurrentComboPoints) String() string

+ func (value *APLValueCurrentComboPoints) Type() proto.APLValueType

+ type APLValueCurrentEnergy struct

+ func (value *APLValueCurrentEnergy) GetFloat(sim *Simulation) float64

+ func (value *APLValueCurrentEnergy) String() string

+ func (value *APLValueCurrentEnergy) Type() proto.APLValueType

+ type APLValueCurrentHealth struct

+ func (value *APLValueCurrentHealth) GetFloat(sim *Simulation) float64

+ func (value *APLValueCurrentHealth) String() string

+ func (value *APLValueCurrentHealth) Type() proto.APLValueType

+ type APLValueCurrentHealthPercent struct

+ func (value *APLValueCurrentHealthPercent) GetFloat(sim *Simulation) float64

+ func (value *APLValueCurrentHealthPercent) String() string

+ func (value *APLValueCurrentHealthPercent) Type() proto.APLValueType

+ type APLValueCurrentMana struct

+ func (value *APLValueCurrentMana) GetFloat(sim *Simulation) float64

+ func (value *APLValueCurrentMana) String() string

+ func (value *APLValueCurrentMana) Type() proto.APLValueType

+ type APLValueCurrentManaPercent struct

+ func (value *APLValueCurrentManaPercent) GetFloat(sim *Simulation) float64

+ func (value *APLValueCurrentManaPercent) String() string

+ func (value *APLValueCurrentManaPercent) Type() proto.APLValueType

+ type APLValueCurrentRage struct

+ func (value *APLValueCurrentRage) GetFloat(sim *Simulation) float64

+ func (value *APLValueCurrentRage) String() string

+ func (value *APLValueCurrentRage) Type() proto.APLValueType

+ type APLValueCurrentTime struct

+ func (value *APLValueCurrentTime) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueCurrentTime) String() string

+ func (value *APLValueCurrentTime) Type() proto.APLValueType

+ type APLValueCurrentTimePercent struct

+ func (value *APLValueCurrentTimePercent) GetFloat(sim *Simulation) float64

+ func (value *APLValueCurrentTimePercent) String() string

+ func (value *APLValueCurrentTimePercent) Type() proto.APLValueType

+ type APLValueDotIsActive struct

+ func (value *APLValueDotIsActive) GetBool(sim *Simulation) bool

+ func (value *APLValueDotIsActive) String() string

+ func (value *APLValueDotIsActive) Type() proto.APLValueType

+ type APLValueDotRemainingTime struct

+ func (value *APLValueDotRemainingTime) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueDotRemainingTime) String() string

+ func (value *APLValueDotRemainingTime) Type() proto.APLValueType

+ type APLValueFrontOfTarget struct

+ func (value *APLValueFrontOfTarget) GetBool(sim *Simulation) bool

+ func (value *APLValueFrontOfTarget) String() string

+ func (value *APLValueFrontOfTarget) Type() proto.APLValueType

+ type APLValueGCDIsReady struct

+ func (value *APLValueGCDIsReady) GetBool(sim *Simulation) bool

+ func (value *APLValueGCDIsReady) String() string

+ func (value *APLValueGCDIsReady) Type() proto.APLValueType

+ type APLValueGCDTimeToReady struct

+ func (value *APLValueGCDTimeToReady) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueGCDTimeToReady) String() string

+ func (value *APLValueGCDTimeToReady) Type() proto.APLValueType

+ type APLValueIsExecutePhase struct

+ func (value *APLValueIsExecutePhase) GetBool(sim *Simulation) bool

+ func (value *APLValueIsExecutePhase) String() string

+ func (value *APLValueIsExecutePhase) Type() proto.APLValueType

+ type APLValueMath struct

+ func (value *APLValueMath) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueMath) GetFloat(sim *Simulation) float64

+ func (value *APLValueMath) GetInnerValues() []APLValue

+ func (value *APLValueMath) GetInt(sim *Simulation) int32

+ func (value *APLValueMath) String() string

+ func (value *APLValueMath) Type() proto.APLValueType

+ type APLValueMax struct

+ func (value *APLValueMax) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueMax) GetFloat(sim *Simulation) float64

+ func (value *APLValueMax) GetInnerValues() []APLValue

+ func (value *APLValueMax) GetInt(sim *Simulation) int32

+ func (value *APLValueMax) String() string

+ func (value *APLValueMax) Type() proto.APLValueType

+ type APLValueMin struct

+ func (value *APLValueMin) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueMin) GetFloat(sim *Simulation) float64

+ func (value *APLValueMin) GetInnerValues() []APLValue

+ func (value *APLValueMin) GetInt(sim *Simulation) int32

+ func (value *APLValueMin) String() string

+ func (value *APLValueMin) Type() proto.APLValueType

+ type APLValueNot struct

+ func (value *APLValueNot) GetBool(sim *Simulation) bool

+ func (value *APLValueNot) GetInnerValues() []APLValue

+ func (value *APLValueNot) String() string

+ func (value *APLValueNot) Type() proto.APLValueType

+ type APLValueNumberTargets struct

+ func (value *APLValueNumberTargets) GetInt(sim *Simulation) int32

+ func (value *APLValueNumberTargets) String() string

+ func (value *APLValueNumberTargets) Type() proto.APLValueType

+ type APLValueOr struct

+ func (value *APLValueOr) GetBool(sim *Simulation) bool

+ func (value *APLValueOr) GetInnerValues() []APLValue

+ func (value *APLValueOr) String() string

+ func (value *APLValueOr) Type() proto.APLValueType

+ type APLValueRemainingTime struct

+ func (value *APLValueRemainingTime) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueRemainingTime) String() string

+ func (value *APLValueRemainingTime) Type() proto.APLValueType

+ type APLValueRemainingTimePercent struct

+ func (value *APLValueRemainingTimePercent) GetFloat(sim *Simulation) float64

+ func (value *APLValueRemainingTimePercent) String() string

+ func (value *APLValueRemainingTimePercent) Type() proto.APLValueType

+ type APLValueSequenceIsComplete struct

+ func (value *APLValueSequenceIsComplete) Finalize(rot *APLRotation)

+ func (value *APLValueSequenceIsComplete) GetBool(sim *Simulation) bool

+ func (value *APLValueSequenceIsComplete) String() string

+ func (value *APLValueSequenceIsComplete) Type() proto.APLValueType

+ type APLValueSequenceIsReady struct

+ func (value *APLValueSequenceIsReady) Finalize(rot *APLRotation)

+ func (value *APLValueSequenceIsReady) GetBool(sim *Simulation) bool

+ func (value *APLValueSequenceIsReady) String() string

+ func (value *APLValueSequenceIsReady) Type() proto.APLValueType

+ type APLValueSequenceTimeToReady struct

+ func (value *APLValueSequenceTimeToReady) Finalize(rot *APLRotation)

+ func (value *APLValueSequenceTimeToReady) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueSequenceTimeToReady) String() string

+ func (value *APLValueSequenceTimeToReady) Type() proto.APLValueType

+ type APLValueSpellCPM struct

+ func (value *APLValueSpellCPM) GetFloat(sim *Simulation) float64

+ func (value *APLValueSpellCPM) String() string

+ func (value *APLValueSpellCPM) Type() proto.APLValueType

+ type APLValueSpellCanCast struct

+ func (value *APLValueSpellCanCast) GetBool(sim *Simulation) bool

+ func (value *APLValueSpellCanCast) String() string

+ func (value *APLValueSpellCanCast) Type() proto.APLValueType

+ type APLValueSpellCastTime struct

+ func (value *APLValueSpellCastTime) GetDuration(_ *Simulation) time.Duration

+ func (value *APLValueSpellCastTime) String() string

+ func (value *APLValueSpellCastTime) Type() proto.APLValueType

+ type APLValueSpellChanneledTicks struct

+ func (value *APLValueSpellChanneledTicks) GetInt(_ *Simulation) int32

+ func (value *APLValueSpellChanneledTicks) String() string

+ func (value *APLValueSpellChanneledTicks) Type() proto.APLValueType

+ type APLValueSpellCurrentCost struct

+ func (value *APLValueSpellCurrentCost) GetFloat(_ *Simulation) float64

+ func (value *APLValueSpellCurrentCost) String() string

+ func (value *APLValueSpellCurrentCost) Type() proto.APLValueType

+ type APLValueSpellIsChanneling struct

+ func (value *APLValueSpellIsChanneling) GetBool(_ *Simulation) bool

+ func (value *APLValueSpellIsChanneling) String() string

+ func (value *APLValueSpellIsChanneling) Type() proto.APLValueType

+ type APLValueSpellIsReady struct

+ func (value *APLValueSpellIsReady) GetBool(sim *Simulation) bool

+ func (value *APLValueSpellIsReady) String() string

+ func (value *APLValueSpellIsReady) Type() proto.APLValueType

+ type APLValueSpellTimeToReady struct

+ func (value *APLValueSpellTimeToReady) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueSpellTimeToReady) String() string

+ func (value *APLValueSpellTimeToReady) Type() proto.APLValueType

+ type APLValueSpellTravelTime struct

+ func (value *APLValueSpellTravelTime) GetDuration(_ *Simulation) time.Duration

+ func (value *APLValueSpellTravelTime) String() string

+ func (value *APLValueSpellTravelTime) Type() proto.APLValueType

+ type APLValueTimeToEnergyTick struct

+ func (value *APLValueTimeToEnergyTick) GetDuration(sim *Simulation) time.Duration

+ func (value *APLValueTimeToEnergyTick) String() string

+ func (value *APLValueTimeToEnergyTick) Type() proto.APLValueType

+ type ActionID struct

+ ItemID int32

+ OtherID proto.OtherAction

+ SpellID int32

+ Tag int32

+ func ProtoToActionID(protoID *proto.ActionID) ActionID

+ func (actionID ActionID) IsEmptyAction() bool

+ func (actionID ActionID) IsItemAction(itemID int32) bool

+ func (actionID ActionID) IsOtherAction(otherID proto.OtherAction) bool

+ func (actionID ActionID) IsSpellAction(spellID int32) bool

+ func (actionID ActionID) SameAction(other ActionID) bool

+ func (actionID ActionID) SameActionIgnoreTag(other ActionID) bool

+ func (actionID ActionID) String() string

+ func (actionID ActionID) ToProto() *proto.ActionID

+ func (actionID ActionID) WithTag(tag int32) ActionID

+ type ActionMetrics struct

+ IsMelee bool

+ Targets []TargetedActionMetrics

+ func (actionMetrics *ActionMetrics) ToProto(actionID ActionID) *proto.ActionMetrics

+ type ActionPriority int32

+ const ActionPriorityAuto

+ const ActionPriorityDOT

+ const ActionPriorityGCD

+ const ActionPriorityLow

+ const ActionPriorityPrePull

+ const ActionPriorityRegen

+ type ActiveSetBonus struct

+ BonusEffect ApplyEffect

+ Name string

+ NumPieces int32

+ type Agent interface

+ AddPartyBuffs func(partyBuffs *proto.PartyBuffs)

+ AddRaidBuffs func(raidBuffs *proto.RaidBuffs)

+ ApplyRunes func()

+ ApplyTalents func()

+ ExecuteCustomRotation func(sim *Simulation)

+ GetCharacter func() *Character

+ Initialize func()

+ NewAPLAction func(rot *APLRotation, config *proto.APLAction) APLActionImpl

+ NewAPLValue func(rot *APLRotation, config *proto.APLValue) APLValue

+ Reset func(sim *Simulation)

+ func NewAgent(party *Party, partyIndex int, player *proto.Player) Agent

+ type AgentFactory func(*Character, *proto.Player) Agent

+ type ApplyEffect func(Agent)

+ func MakeTemporaryStatsOnUseCDRegistration(auraLabel string, tempStats stats.Stats, duration time.Duration, ...) ApplyEffect

+ type ApplySpellResults func(sim *Simulation, target *Unit, spell *Spell)

+ type ApplyWeaponEffect func(Agent, proto.ItemSlot)

+ type AttackTable struct

+ Attacker *Unit

+ BaseBlockChance float64

+ BaseDodgeChance float64

+ BaseGlanceChance float64

+ BaseMissChance float64

+ BaseParryChance float64

+ BaseSpellMissChance float64

+ DamageDealtMultiplier float64

+ DamageTakenMultiplier float64

+ Defender *Unit

+ GlanceMultiplierMax float64

+ GlanceMultiplierMin float64

+ HauntSEDamageTakenMultiplier float64

+ HealingDealtMultiplier float64

+ HitSuppression float64

+ MeleeCritSuppression float64

+ NatureDamageTakenMultiplier float64

+ SpellCritSuppression float64

+ Weapon *Item

+ func NewAttackTable(attacker *Unit, defender *Unit, weapon *Item) *AttackTable

+ func (at *AttackTable) GetArmorDamageModifier(spell *Spell) float64

+ func (at *AttackTable) GetBinaryHitChance(si stats.SchoolIndex) float64

+ func (at *AttackTable) GetPartialResistThresholds(si stats.SchoolIndex, pureDot bool) (float64, float64, float64)

+ type Aura struct

+ ActionID ActionID

+ ActionIDForProc ActionID

+ BuildPhase CharacterBuildPhase

+ Duration time.Duration

+ ExclusiveEffects []*ExclusiveEffect

+ Icd *Cooldown

+ Label string

+ MaxStacks int32

+ OnCastComplete OnCastComplete

+ OnDoneIteration OnDoneIteration

+ OnExpire OnExpire

+ OnGain OnGain

+ OnHealDealt OnSpellHit

+ OnHealTaken OnSpellHit

+ OnInit OnInit

+ OnPeriodicDamageDealt OnPeriodicDamage

+ OnPeriodicDamageTaken OnPeriodicDamage

+ OnPeriodicHealDealt OnPeriodicDamage

+ OnPeriodicHealTaken OnPeriodicDamage

+ OnRageChange OnRageChange

+ OnReset OnReset

+ OnSpellHitDealt OnSpellHit

+ OnSpellHitTaken OnSpellHit

+ OnStacksChange OnStacksChange

+ OnStatsChange OnStatsChange

+ Tag string

+ Unit *Unit

+ func AncientCorrosivePoisonAura(target *Unit) *Aura

+ func ApplyWildStrikes(character *Character) *Aura

+ func ApplyWindfury(character *Character) *Aura

+ func BattleShoutAura(unit *Unit, impBattleShout int32, boomingVoicePts int32) *Aura

+ func BlessingOfMightAura(unit *Unit, impBomPts int32, level int32) *Aura

+ func BloodlustAura(character *Character, actionTag int32) *Aura

+ func CommandingShoutAura(unit *Unit, commandingPresencePts int32, boomingVoicePts int32) *Aura

+ func CrystalYieldAura(target *Unit) *Aura

+ func CurseOfElementsAura(target *Unit, playerLevel int32) *Aura

+ func CurseOfRecklessnessAura(target *Unit, playerLevel int32) *Aura

+ func CurseOfShadowAura(target *Unit, playerLevel int32) *Aura

+ func CurseOfVulnerabilityAura(target *Unit) *Aura

+ func CurseOfWeaknessAura(target *Unit, points int32, playerLevel int32) *Aura

+ func DemonicPactAura(unit *Unit, spellpower float64) *Aura

+ func DemoralizingRoarAura(target *Unit, points int32, playerLevel int32) *Aura

+ func DemoralizingShoutAura(target *Unit, boomingVoicePts int32, impDemoShoutPts int32, playerLevel int32) *Aura

+ func DragonBreathChiliAura(character *Character) *Aura

+ func DreamstateAura(unit *Unit) *Aura

+ func ExposeArmorAura(target *Unit, improvedEA int32, playerLevel int32) *Aura

+ func FaerieFireAura(target *Unit, playerLevel int32) *Aura

+ func GiftOfArthasAura(target *Unit) *Aura

+ func GraceOfAirTotemAura(unit *Unit, level int32, multiplier float64) *Aura

+ func GuardianSpiritAura(character *Character, actionTag int32) *Aura

+ func HandOfSacrificeAura(character *Character, actionTag int32) *Aura

+ func HemorrhageAura(target *Unit, casterLevel int32) *Aura

+ func HomunculiArmorAura(target *Unit, playerLevel int32) *Aura

+ func HomunculiAttackPowerAura(target *Unit, playerLevel int32) *Aura

+ func HomunculiAttackSpeedAura(target *Unit, playerLevel int32) *Aura

+ func HuntersMarkAura(target *Unit, points int32, playerLevel int32) *Aura

+ func ImprovedScorchAura(target *Unit) *Aura

+ func ImprovedShadowBoltAura(unit *Unit, rank int32) *Aura

+ func InnervateAura(character *Character, actionTag int32) *Aura

+ func InsectSwarmAura(target *Unit) *Aura

+ func InspirationAura(unit *Unit, points int32) *Aura

+ func JudgementOfLightAura(target *Unit) *Aura

+ func JudgementOfWisdomAura(target *Unit, level int32) *Aura

+ func MakePermanent(aura *Aura) *Aura

+ func MakeProcTriggerAura(unit *Unit, config ProcTrigger) *Aura

+ func MakeStackingAura(character *Character, config StackingStatAura) *Aura

+ func ManaTideTotemAura(character *Character, actionTag int32) *Aura

+ func MangleAura(target *Unit, playerLevel int32) *Aura

+ func MekkatorqueFistDebuffAura(target *Unit, playerLevel int32) *Aura

+ func PainSuppressionAura(character *Character, actionTag int32) *Aura

+ func PowerInfusionAura(character *Unit, actionTag int32) *Aura

+ func RetributionAura(character *Character, sanctifiedRetribution bool) *Aura

+ func ScorpidStingAura(target *Unit) *Aura

+ func ShadowWeavingAura(unit *Unit, rank int) *Aura

+ func StormstrikeAura(unit *Unit) *Aura

+ func StrengthOfEarthTotemAura(unit *Unit, level int32, multiplier float64) *Aura

+ func SunderArmorAura(target *Unit, playerLevel int32) *Aura

+ func ThornsAura(character *Character, points int32) *Aura

+ func ThunderClapAura(target *Unit, spellID int32, duration time.Duration, ...) *Aura

+ func TricksOfTheTradeAura(character *Unit, actionTag int32) *Aura

+ func VindicationAura(target *Unit, points int32, playerLevel int32) *Aura

+ func WaylayAura(target *Unit) *Aura

+ func WintersChillAura(target *Unit, startingStacks int32) *Aura

+ func (aura *Aura) Activate(sim *Simulation)

+ func (aura *Aura) AddStack(sim *Simulation)

+ func (aura *Aura) AddStacks(sim *Simulation, numStacks int32)

+ func (aura *Aura) ApplyOnExpire(newOnExpire OnExpire)

+ func (aura *Aura) ApplyOnGain(newOnGain OnGain)

+ func (aura *Aura) Deactivate(sim *Simulation)

+ func (aura *Aura) ExpiresAt() time.Duration

+ func (aura *Aura) GetStacks() int32

+ func (aura *Aura) IsActive() bool

+ func (aura *Aura) NewExclusiveEffect(categoryName string, singleAura bool, config ExclusiveEffect) *ExclusiveEffect

+ func (aura *Aura) Refresh(sim *Simulation)

+ func (aura *Aura) RemainingDuration(sim *Simulation) time.Duration

+ func (aura *Aura) RemoveStack(sim *Simulation)

+ func (aura *Aura) SetStacks(sim *Simulation, newStacks int32)

+ func (aura *Aura) ShouldRefreshExclusiveEffects(sim *Simulation, refreshWindow time.Duration) bool

+ func (aura *Aura) StartedAt() time.Duration

+ func (aura *Aura) TimeActive(sim *Simulation) time.Duration

+ func (aura *Aura) UpdateExpires(sim *Simulation, newExpires time.Duration)

+ type AuraArray []*Aura

+ func (auras AuraArray) Get(target *Unit) *Aura

+ type AuraCallback uint16

+ const CallbackEmpty

+ const CallbackOnCastComplete

+ const CallbackOnHealDealt

+ const CallbackOnPeriodicDamageDealt

+ const CallbackOnPeriodicHealDealt

+ const CallbackOnSpellHitDealt

+ const CallbackOnSpellHitTaken

+ func (c AuraCallback) Matches(other AuraCallback) bool

+ type AuraFactory func(*Simulation) *Aura

+ type AuraMetrics struct

+ ID ActionID

+ Procs int32

+ Uptime time.Duration

+ func (auraMetrics *AuraMetrics) ToProto() *proto.AuraMetrics

+ type AuraReference struct

+ func NewAuraReference(sourceUnit UnitReference, auraId *proto.ActionID) AuraReference

+ func NewIcdAuraReference(sourceUnit UnitReference, auraId *proto.ActionID) AuraReference

+ func (ar *AuraReference) Get() *Aura

+ func (ar *AuraReference) String() string

+ type AutoAttackOptions struct

+ AutoSwingMelee bool

+ AutoSwingRanged bool

+ MainHand Weapon

+ OffHand Weapon

+ Ranged Weapon

+ ReplaceMHSwing ReplaceMHSwing

+ type AutoAttacks struct

+ AutoSwingMelee bool

+ AutoSwingRanged bool

+ IsDualWielding bool

+ func (aa *AutoAttacks) CancelAutoSwing(sim *Simulation)

+ func (aa *AutoAttacks) DelayMeleeBy(sim *Simulation, delay time.Duration)

+ func (aa *AutoAttacks) DelayRangedUntil(sim *Simulation, readyAt time.Duration)

+ func (aa *AutoAttacks) EnableAutoSwing(sim *Simulation)

+ func (aa *AutoAttacks) ExtraMHAttack(sim *Simulation)

+ func (aa *AutoAttacks) MH() *Weapon

+ func (aa *AutoAttacks) MHAuto() *Spell

+ func (aa *AutoAttacks) MHConfig() *SpellConfig

+ func (aa *AutoAttacks) MainhandSwingAt() time.Duration

+ func (aa *AutoAttacks) MainhandSwingSpeed() time.Duration

+ func (aa *AutoAttacks) MaybeReplaceMHSwing(sim *Simulation, mhSwingSpell *Spell) *Spell

+ func (aa *AutoAttacks) NewPPMManager(ppm float64, procMask ProcMask) PPMManager

+ func (aa *AutoAttacks) NextAnyAttackAt() time.Duration

+ func (aa *AutoAttacks) NextAttackAt() time.Duration

+ func (aa *AutoAttacks) NextRangedAttackAt() time.Duration

+ func (aa *AutoAttacks) OH() *Weapon

+ func (aa *AutoAttacks) OHAuto() *Spell

+ func (aa *AutoAttacks) OHConfig() *SpellConfig

+ func (aa *AutoAttacks) OffhandSwingAt() time.Duration

+ func (aa *AutoAttacks) OffhandSwingSpeed() time.Duration

+ func (aa *AutoAttacks) PPMProc(sim *Simulation, ppm float64, procMask ProcMask, label string, spell *Spell) bool

+ func (aa *AutoAttacks) Ranged() *Weapon

+ func (aa *AutoAttacks) RangedAuto() *Spell

+ func (aa *AutoAttacks) RangedConfig() *SpellConfig

+ func (aa *AutoAttacks) RangedSwingSpeed() time.Duration

+ func (aa *AutoAttacks) SetMH(weapon Weapon)

+ func (aa *AutoAttacks) SetOH(weapon Weapon)

+ func (aa *AutoAttacks) SetOffhandSwingAt(offhandSwingAt time.Duration)

+ func (aa *AutoAttacks) SetRanged(weapon Weapon)

+ func (aa *AutoAttacks) SetReplaceMHSwing(replaceSwing ReplaceMHSwing)

+ func (aa *AutoAttacks) StopMeleeUntil(sim *Simulation, readyAt time.Duration, desyncOH bool)

+ func (aa *AutoAttacks) UpdateSwingTimers(sim *Simulation)

+ type BaseStatsKey struct

+ Class proto.Class

+ Level int

+ Race proto.Race

+ type BuffName int32

+ const ArcaneIntellect

+ const AspectOfTheWild

+ const BattleShout

+ const BlessingOfMight

+ const BlessingOfWisdom

+ const BloodPact

+ const DivineSpirit

+ const FrostResistanceAura

+ const FrostResistanceTotem

+ const GraceOfAir

+ const HornOfLordaeron

+ const ManaSpring

+ const MarkOfTheWild

+ const NatureResistanceTotem

+ const PowerWordFortitude

+ const SanctityAura

+ const ScrollOfAgility

+ const ScrollOfIntellect

+ const ScrollOfSpirit

+ const ScrollOfStamina

+ const ScrollOfStrength

+ const ShadowProtection

+ const StrengthOfEarth

+ const TrueshotAura

+ const Windfury

+ type BuffsCombo struct

+ Consumes []ConsumesCombo

+ Debuffs *proto.Debuffs

+ Label string

+ Party *proto.PartyBuffs

+ Player *proto.IndividualBuffs

+ Raid *proto.RaidBuffs

+ type CanCastCondition func(sim *Simulation, target *Unit) bool

+ type Cast struct

+ CastTime time.Duration

+ Cost float64

+ GCD time.Duration

+ func (cast *Cast) EffectiveTime() time.Duration

+ type CastConfig struct

+ CD Cooldown

+ CastTime func(spell *Spell) time.Duration

+ DefaultCast Cast

+ IgnoreHaste bool

+ ModifyCast func(*Simulation, *Spell, *Cast)

+ SharedCD Cooldown

+ type CastFunc func(*Simulation, *Unit)

+ type CastSuccessFunc func(*Simulation, *Unit) bool

+ type Character struct

+ Class proto.Class

+ Consumes *proto.Consumes

+ ItemSwap ItemSwap

+ Name string

+ Party *Party

+ PartyIndex int

+ Pets []*Pet

+ PrimaryTalentTree uint8

+ Race proto.Race

+ Spec proto.Spec

+ func NewCharacter(party *Party, partyIndex int, player *proto.Player) Character

+ func (at *Character) GetActiveAuraWithTag(tag string) *Aura

+ func (at *Character) GetAura(label string) *Aura

+ func (at *Character) GetAuraByID(actionID ActionID) *Aura

+ func (at *Character) GetAuras() []*Aura

+ func (at *Character) GetAurasWithTag(tag string) []*Aura

+ func (at *Character) GetIcdAuraByID(actionID ActionID) *Aura

+ func (at *Character) HasActiveAura(label string) bool

+ func (at *Character) HasActiveAuraWithTag(tag string) bool

+ func (at *Character) HasActiveAuraWithTagExcludingAura(tag string, excludeAura *Aura) bool

+ func (at *Character) HasAura(label string) bool

+ func (at *Character) HasAuraWithTag(tag string) bool

+ func (at *Character) NumActiveAurasWithTag(tag string) int32

+ func (at *Character) OnCastComplete(sim *Simulation, spell *Spell)

+ func (at *Character) OnHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) OnHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) OnPeriodicDamageDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) OnPeriodicDamageTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) OnPeriodicHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) OnPeriodicHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) OnRageChange(sim *Simulation, metrics *ResourceMetrics)

+ func (at *Character) OnSpellHitDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) OnSpellHitTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Character) RegisterResetEffect(resetEffect ResetEffect)

+ func (character *Character) AddPartyBuffs(partyBuffs *proto.PartyBuffs)

+ func (character *Character) AddPet(pet PetAgent)

+ func (character *Character) AddRaidBuffs(_ *proto.RaidBuffs)

+ func (character *Character) ApplyDynamicEquipScaling(sim *Simulation, stat stats.Stat, multiplier float64)

+ func (character *Character) ApplyEquipScaling(stat stats.Stat, multiplier float64)

+ func (character *Character) BaseEquipStats() stats.Stats

+ func (character *Character) DefaultHealingCritMultiplier() float64

+ func (character *Character) DefaultMeleeCritMultiplier() float64

+ func (character *Character) DefaultSpellCritMultiplier() float64

+ func (character *Character) EnableManaBar()

+ func (character *Character) EnableManaBarWithModifier(modifier float64)

+ func (character *Character) EquipStats() stats.Stats

+ func (character *Character) FillPlayerStats(playerStats *proto.PlayerStats)

+ func (character *Character) Finalize()

+ func (character *Character) GetActiveSetBonusNames() []string

+ func (character *Character) GetActiveSetBonuses() []ActiveSetBonus

+ func (character *Character) GetBaseStats() stats.Stats

+ func (character *Character) GetConjuredCD() *Timer

+ func (character *Character) GetDefensiveTrinketCD() *Timer

+ func (character *Character) GetMHWeapon() *Item

+ func (character *Character) GetMetricsProto() *proto.UnitMetrics

+ func (character *Character) GetOHWeapon() *Item

+ func (character *Character) GetOffensiveTrinketCD() *Timer

+ func (character *Character) GetPresimOptions(playerConfig *proto.Player) *PresimOptions

+ func (character *Character) GetProcMaskForEnchant(effectID int32) ProcMask

+ func (character *Character) GetProcMaskForItem(itemID int32) ProcMask

+ func (character *Character) GetProcMaskForTypes(weaponTypes ...proto.WeaponType) ProcMask

+ func (character *Character) GetPseudoStatsProto() []float64

+ func (character *Character) GetRangedWeapon() *Item

+ func (character *Character) HasMHWeapon() bool

+ func (character *Character) HasOHWeapon() bool

+ func (character *Character) HasProfession(prof proto.Profession) bool

+ func (character *Character) HasRangedWeapon() bool

+ func (character *Character) HasRingEquipped(itemID int32) bool

+ func (character *Character) HasRuneById(id int32) bool

+ func (character *Character) HasSetBonus(set *ItemSet, numItems int32) bool

+ func (character *Character) HasTrinketEquipped(itemID int32) bool

+ func (character *Character) HealingCritMultiplier(primaryModifiers float64, secondaryModifiers float64) float64

+ func (character *Character) IsTanking() bool

+ func (character *Character) MeleeCritMultiplier(primaryModifiers float64, secondaryModifiers float64) float64

+ func (character *Character) NewTemporaryStatsAura(auraLabel string, actionID ActionID, tempStats stats.Stats, ...) *Aura

+ func (character *Character) NewTemporaryStatsAuraWrapped(auraLabel string, actionID ActionID, buffs stats.Stats, duration time.Duration, ...) *Aura

+ func (character *Character) RegisterOnItemSwap(callback OnSwapItem)

+ func (character *Character) RemoveDynamicEquipScaling(sim *Simulation, stat stats.Stat, multiplier float64)

+ func (character *Character) RemoveEquipScaling(stat stats.Stat, multiplier float64)

+ func (character *Character) SpellCritMultiplier(primaryModifiers float64, secondaryModifiers float64) float64

+ func (character *Character) WeaponFromMainHand(critMultiplier float64) Weapon

+ func (character *Character) WeaponFromOffHand(critMultiplier float64) Weapon

+ func (character *Character) WeaponFromRanged(critMultiplier float64) Weapon

+ func (eb *Character) AddComboPoints(sim *Simulation, pointsToAdd int32, metrics *ResourceMetrics)

+ func (eb *Character) AddEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (eb *Character) ComboPoints() int32

+ func (eb *Character) CurrentEnergy() float64

+ func (eb *Character) NextEnergyTickAt() time.Duration

+ func (eb *Character) ResetEnergyTick(sim *Simulation)

+ func (eb *Character) SpendComboPoints(sim *Simulation, metrics *ResourceMetrics)

+ func (eb *Character) SpendEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Character) AddFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Character) CurrentFocus() float64

+ func (fb *Character) CurrentFocusPerTick() float64

+ func (fb *Character) SpendFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Character) CurrentHealth() float64

+ func (hb *Character) CurrentHealthPercent() float64

+ func (hb *Character) GainHealth(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Character) MaxHealth() float64

+ func (hb *Character) RemoveHealth(sim *Simulation, amount float64)

+ func (mb *Character) EndOOMEvent(sim *Simulation)

+ func (mb *Character) IsOOM() bool

+ func (mb *Character) StartOOMEvent(sim *Simulation, requiredMana float64)

+ func (mcdm *Character) AddMajorCooldown(mcd MajorCooldown)

+ func (mcdm *Character) GetInitialMajorCooldown(actionID ActionID) MajorCooldown

+ func (mcdm *Character) GetMajorCooldown(actionID ActionID) *MajorCooldown

+ func (mcdm *Character) GetMajorCooldownIDs() []*proto.ActionID

+ func (mcdm *Character) GetMajorCooldownIgnoreTag(actionID ActionID) *MajorCooldown

+ func (mcdm *Character) GetMajorCooldowns() []*MajorCooldown

+ func (mcdm *Character) TryUseCooldowns(sim *Simulation)

+ func (mcdm *Character) UpdateMajorCooldowns()

+ func (rb *Character) AddRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (rb *Character) CurrentRage() float64

+ func (rb *Character) SpendRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ type CharacterBuildPhase uint8

+ const CharacterBuildPhaseBase

+ const CharacterBuildPhaseBuffs

+ const CharacterBuildPhaseConsumes

+ const CharacterBuildPhaseGear

+ const CharacterBuildPhaseNone

+ const CharacterBuildPhaseTalents

+ func (cbp CharacterBuildPhase) Matches(other CharacterBuildPhase) bool

+ type CharacterIterationMetrics struct

+ Died bool

+ FirstOOMTimestamp time.Duration

+ ManaGained float64

+ ManaSpent float64

+ OOMTime time.Duration

+ WentOOM bool

+ type CharacterSuiteConfig struct

+ Buffs BuffsCombo

+ Class proto.Class

+ Consumes ConsumesCombo

+ Cooldowns *proto.Cooldowns

+ EPReferenceStat proto.Stat

+ GearSet GearSetCombo

+ InFrontOfTarget bool

+ IsHealer bool

+ IsTank bool

+ ItemFilter ItemFilter

+ Level int32

+ OtherConsumes []ConsumesCombo

+ OtherGearSets []GearSetCombo

+ OtherRaces []proto.Race

+ OtherRotations []RotationCombo

+ OtherSpecOptions []SpecOptionsCombo

+ Race proto.Race

+ Rotation RotationCombo

+ SpecOptions SpecOptionsCombo

+ StatsToWeigh []proto.Stat

+ Talents string

+ type CombinedTestGenerator struct

+ func (generator *CombinedTestGenerator) GetTest(testIdx int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ func (generator *CombinedTestGenerator) NumTests() int

+ type ConsumesCombo struct

+ Consumes *proto.Consumes

+ Label string

+ type Cooldown struct

+ Duration time.Duration

+ func (cd *Cooldown) Use(sim *Simulation)

+ type CooldownActivation func(*Simulation, *Character)

+ type CooldownActivationCondition func(*Simulation, *Character) bool

+ type CooldownType byte

+ const CooldownTypeDPS

+ const CooldownTypeExplosive

+ const CooldownTypeMana

+ const CooldownTypeSurvival

+ const CooldownTypeUnknown

+ func (ct CooldownType) Matches(other CooldownType) bool

+ type DebuffName int32

+ const DemoralizingShout

+ type DefaultAPLValueImpl struct

+ func (impl DefaultAPLValueImpl) Finalize(*APLRotation)

+ func (impl DefaultAPLValueImpl) GetBool(sim *Simulation) bool

+ func (impl DefaultAPLValueImpl) GetDuration(sim *Simulation) time.Duration

+ func (impl DefaultAPLValueImpl) GetFloat(sim *Simulation) float64

+ func (impl DefaultAPLValueImpl) GetInnerValues() []APLValue

+ func (impl DefaultAPLValueImpl) GetInt(sim *Simulation) int32

+ func (impl DefaultAPLValueImpl) GetString(sim *Simulation) string

+ type DefenseType byte

+ const DefenseTypeMagic

+ const DefenseTypeMelee

+ const DefenseTypeNone

+ const DefenseTypeRanged

+ type DelayedActionOptions struct

+ CleanUp func(*Simulation)

+ DoAt time.Duration

+ OnAction func(*Simulation)

+ Priority ActionPriority

+ type DistributionMetrics struct

+ Total float64

+ func NewDistributionMetrics() DistributionMetrics

+ func (distMetrics *DistributionMetrics) ToProto() *proto.DistributionMetrics

+ type Dot struct

+ AffectedByCastSpeed bool

+ NumberOfTicks int32

+ OnSnapshot OnSnapshot

+ OnTick OnTick

+ SnapshotAttackerMultiplier float64

+ SnapshotBaseDamage float64

+ SnapshotCritChance float64

+ Spell *Spell

+ TickCount int32

+ TickLength time.Duration

+ func (dot *Dot) Apply(sim *Simulation)

+ func (dot *Dot) ApplyOrRefresh(sim *Simulation)

+ func (dot *Dot) ApplyOrReset(sim *Simulation)

+ func (dot *Dot) CalcAndDealPeriodicSnapshotDamage(sim *Simulation, target *Unit, outcomeApplier OutcomeApplier) *SpellResult

+ func (dot *Dot) CalcAndDealPeriodicSnapshotHealing(sim *Simulation, target *Unit, outcomeApplier OutcomeApplier) *SpellResult

+ func (dot *Dot) CalcSnapshotDamage(sim *Simulation, target *Unit, outcomeApplier OutcomeApplier) *SpellResult

+ func (dot *Dot) CalcSnapshotHealing(sim *Simulation, target *Unit, outcomeApplier OutcomeApplier) *SpellResult

+ func (dot *Dot) Cancel(sim *Simulation)

+ func (dot *Dot) ManualTick(sim *Simulation)

+ func (dot *Dot) MaxTicksRemaining() int32

+ func (dot *Dot) NextTickAt() time.Duration

+ func (dot *Dot) NumTicksRemaining(sim *Simulation) int

+ func (dot *Dot) OutcomeExpectedMagicSnapshotCrit(_ *Simulation, result *SpellResult, _ *AttackTable)

+ func (dot *Dot) OutcomeMagicHitAndSnapshotCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (dot *Dot) OutcomeRangedHitAndCritSnapshot(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (dot *Dot) OutcomeSnapshotCrit(sim *Simulation, result *SpellResult, _ *AttackTable)

+ func (dot *Dot) OutcomeTick(_ *Simulation, result *SpellResult, _ *AttackTable)

+ func (dot *Dot) OutcomeTickCounted(_ *Simulation, result *SpellResult, _ *AttackTable)

+ func (dot *Dot) OutcomeTickPhysicalCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (dot *Dot) OutcomeTickSnapshotCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (dot *Dot) RecomputeAuraDuration()

+ func (dot *Dot) RescheduleNextTick(sim *Simulation)

+ func (dot *Dot) Rollover(sim *Simulation)

+ func (dot *Dot) TakeSnapshot(sim *Simulation, doRollover bool)

+ func (dot *Dot) TickOnce(sim *Simulation)

+ func (dot *Dot) TickPeriod() time.Duration

+ func (dot *Dot) TimeUntilNextTick(sim *Simulation) time.Duration

+ type DotArray []*Dot

+ func (dots DotArray) Get(target *Unit) *Dot

+ type DotConfig struct

+ AffectedByCastSpeed bool

+ Aura Aura

+ IsAOE bool

+ NumberOfTicks int32

+ OnSnapshot OnSnapshot

+ OnTick OnTick

+ SelfOnly bool

+ Spell *Spell

+ TickLength time.Duration

+ type DynamicDamageTakenModifier func(sim *Simulation, spell *Spell, result *SpellResult)

+ type Enchant struct

+ EffectID int32

+ Stats stats.Stats

+ func EnchantFromProto(pData *proto.SimEnchant) Enchant

+ type Encounter struct

+ DamageTaken float64

+ Duration time.Duration

+ DurationIsEstimate bool

+ DurationVariation time.Duration

+ EndFightAtHealth float64

+ ExecuteProportion_20 float64

+ ExecuteProportion_25 float64

+ ExecuteProportion_35 float64

+ TargetUnits []*Unit

+ Targets []*Target

+ func NewEncounter(options *proto.Encounter) Encounter

+ func (encounter *Encounter) AOECapMultiplier() float64

+ func (encounter *Encounter) GetMetricsProto() *proto.EncounterMetrics

+ type EncounterCombo struct

+ Encounter *proto.Encounter

+ Label string

+ func MakeDefaultEncounterCombos(playerLevel int32) []EncounterCombo

+ type EnergyCost struct

+ ComboPointMetrics *ResourceMetrics

+ Refund float64

+ RefundMetrics *ResourceMetrics

+ ResourceMetrics *ResourceMetrics

+ func (ec *EnergyCost) CostFailureReason(_ *Simulation, spell *Spell) string

+ func (ec *EnergyCost) IssueRefund(sim *Simulation, spell *Spell)

+ func (ec *EnergyCost) MeetsRequirement(_ *Simulation, spell *Spell) bool

+ func (ec *EnergyCost) SpendCost(sim *Simulation, spell *Spell)

+ type EnergyCostOptions struct

+ Cost float64

+ Refund float64

+ RefundMetrics *ResourceMetrics

+ type Environment struct

+ AllUnits []*Unit

+ BaseDuration time.Duration

+ DurationVariation time.Duration

+ Encounter Encounter

+ MeasuringStats bool

+ Raid *Raid

+ State EnvironmentState

+ func NewEnvironment(raidProto *proto.Raid, encounterProto *proto.Encounter, runFakePrepull bool) (*Environment, *proto.RaidStats, *proto.EncounterStats)

+ func (env *Environment) GetAgentFromUnit(unit *Unit) Agent

+ func (env *Environment) GetMaxDuration() time.Duration

+ func (env *Environment) GetNumTargets() int32

+ func (env *Environment) GetTarget(index int32) *Target

+ func (env *Environment) GetTargetUnit(index int32) *Unit

+ func (env *Environment) GetUnit(ref *proto.UnitReference, contextUnit *Unit) *Unit

+ func (env *Environment) IsFinalized() bool

+ func (env *Environment) NextTarget(target *Unit) *Target

+ func (env *Environment) NextTargetUnit(target *Unit) *Unit

+ func (env *Environment) PrepullStartTime() time.Duration

+ func (env *Environment) RegisterPostFinalizeEffect(postFinalizeEffect PostFinalizeEffect)

+ func (env *Environment) RegisterPreFinalizeEffect(preFinalizeEffect PostFinalizeEffect)

+ type EnvironmentState int

+ const Constructed

+ const Created

+ const Finalized

+ const Initialized

+ type Equipment [proto.ItemSlot_ItemSlotRanged + 1]Item

+ func NewEquipmentSet(equipSpec EquipmentSpec) Equipment

+ func ProtoToEquipment(es *proto.EquipmentSpec) Equipment

+ func (equipment *Equipment) BaseStats() stats.Stats

+ func (equipment *Equipment) EquipItem(item Item)

+ func (equipment *Equipment) Finger1() *Item

+ func (equipment *Equipment) Finger2() *Item

+ func (equipment *Equipment) GetRuneIds() []int32

+ func (equipment *Equipment) Hands() *Item

+ func (equipment *Equipment) Head() *Item

+ func (equipment *Equipment) MainHand() *Item

+ func (equipment *Equipment) Neck() *Item

+ func (equipment *Equipment) OffHand() *Item

+ func (equipment *Equipment) Ranged() *Item

+ func (equipment *Equipment) Stats() stats.Stats

+ func (equipment *Equipment) ToEquipmentSpecProto() *proto.EquipmentSpec

+ func (equipment *Equipment) Trinket1() *Item

+ func (equipment *Equipment) Trinket2() *Item

+ type EquipmentSpec [proto.ItemSlot_ItemSlotRanged + 1]ItemSpec

+ func ProtoToEquipmentSpec(es *proto.EquipmentSpec) EquipmentSpec

+ type ExclusiveCategory struct

+ Name string

+ SingleAura bool

+ func (ec *ExclusiveCategory) AnyActive() bool

+ func (ec *ExclusiveCategory) GetActiveAura() *Aura

+ func (ec *ExclusiveCategory) GetActiveEffect() *ExclusiveEffect

+ func (ec *ExclusiveCategory) GetHighestPrioActiveEffect() *ExclusiveEffect

+ func (ec *ExclusiveCategory) SetActive(sim *Simulation, newActiveEffect *ExclusiveEffect)

+ type ExclusiveCategoryArray []*ExclusiveCategory

+ func (categories ExclusiveCategoryArray) Get(target *Unit) *ExclusiveCategory

+ type ExclusiveEffect struct

+ Aura *Aura

+ Category *ExclusiveCategory

+ OnExpire func(*ExclusiveEffect, *Simulation)

+ OnGain func(*ExclusiveEffect, *Simulation)

+ Priority float64

+ func AtkSpeedReductionEffect(aura *Aura, speedMultiplier float64) *ExclusiveEffect

+ func RegisterPercentDamageModifierEffect(aura *Aura, percentDamageModifier float64) *ExclusiveEffect

+ func (ee *ExclusiveEffect) Activate(sim *Simulation) bool

+ func (ee *ExclusiveEffect) Deactivate(sim *Simulation)

+ func (ee *ExclusiveEffect) IsActive() bool

+ func (ee *ExclusiveEffect) SetPriority(sim *Simulation, newPrio float64)

+ type ExclusiveEffectManager struct

+ func (eem *ExclusiveEffectManager) GetExclusiveEffectCategory(categoryName string) *ExclusiveCategory

+ type ExpectedDamageCalculator func(sim *Simulation, target *Unit, spell *Spell, useSnapshot bool) *SpellResult

+ type FocusCost struct

+ Refund float64

+ RefundMetrics *ResourceMetrics

+ ResourceMetrics *ResourceMetrics

+ func (fc *FocusCost) CostFailureReason(_ *Simulation, spell *Spell) string

+ func (fc *FocusCost) IssueRefund(sim *Simulation, spell *Spell)

+ func (fc *FocusCost) MeetsRequirement(_ *Simulation, spell *Spell) bool

+ func (fc *FocusCost) SpendCost(sim *Simulation, spell *Spell)

+ type FocusCostOptions struct

+ Cost float64

+ Refund float64

+ RefundMetrics *ResourceMetrics

+ type GearSetCombo struct

+ GearSet *proto.EquipmentSpec

+ Label string

+ func GetGearSet(dir string, file string) GearSetCombo

+ type GoRand struct

+ func NewGoRand(seed uint64) *GoRand

+ func (g GoRand) Next() uint64

+ func (g GoRand) NextFloat64() float64

+ type Hand bool

+ const MainHand

+ const OffHand

+ type Hardcast struct

+ ActionID ActionID

+ Expires time.Duration

+ OnComplete func(*Simulation, *Unit)

+ Pushback float64

+ Target *Unit

+ type HitOutcome uint16

+ const OutcomeBlock

+ const OutcomeCrit

+ const OutcomeCrush

+ const OutcomeDodge

+ const OutcomeEmpty

+ const OutcomeGlance

+ const OutcomeHit

+ const OutcomeMiss

+ const OutcomeParry

+ const OutcomePartial1_4

+ const OutcomePartial2_4

+ const OutcomePartial3_4

+ func (ho HitOutcome) Matches(other HitOutcome) bool

+ func (ho HitOutcome) PartialResistString() string

+ func (ho HitOutcome) String() string

+ type IndividualTestSuite struct

+ Name string

+ func NewIndividualTestSuite(suiteName string) *IndividualTestSuite

+ func (testSuite *IndividualTestSuite) Done(t *testing.T)

+ func (testSuite *IndividualTestSuite) TestCasts(testName string, rsr *proto.RaidSimRequest)

+ func (testSuite *IndividualTestSuite) TestCharacterStats(testName string, csr *proto.ComputeStatsRequest)

+ func (testSuite *IndividualTestSuite) TestDPS(testName string, rsr *proto.RaidSimRequest)

+ func (testSuite *IndividualTestSuite) TestStatWeights(testName string, swr *proto.StatWeightsRequest)

+ type Item struct

+ ArmorType proto.ArmorType

+ Enchant Enchant

+ HandType proto.HandType

+ ID int32

+ Name string

+ Quality proto.ItemQuality

+ RandomSuffix RandomSuffix

+ RangedWeaponType proto.RangedWeaponType

+ Rune int32

+ SetName string

+ Stats stats.Stats

+ SwingSpeed float64

+ TempEnchant int32

+ Type proto.ItemType

+ WeaponDamageMax float64

+ WeaponDamageMin float64

+ WeaponSkills stats.WeaponSkills

+ WeaponType proto.WeaponType

+ func ItemFromProto(pData *proto.SimItem) Item

+ func NewItem(itemSpec ItemSpec) Item

+ func (item *Item) ToItemSpecProto() *proto.ItemSpec

+ type ItemComboChecker map[int64]struct

+ func (ic *ItemComboChecker) HasCombo(itema int32, itemb int32) bool

+ type ItemFilter struct

+ ArmorType proto.ArmorType

+ Class proto.Class

+ HandTypes []proto.HandType

+ IDBlacklist []int32

+ RangedWeaponTypes []proto.RangedWeaponType

+ WeaponTypes []proto.WeaponType

+ func (filter *ItemFilter) FindAllItems() []Item

+ func (filter *ItemFilter) FindAllSets() []*ItemSet

+ func (filter *ItemFilter) Matches(item Item, equipChecksOnly bool) bool

+ type ItemSet struct

+ AlternativeName string

+ Bonuses map[int32]ApplyEffect

+ Name string

+ func NewItemSet(set ItemSet) *ItemSet

+ func (set ItemSet) Items() []Item

+ type ItemSpec struct

+ Enchant int32

+ ID int32

+ RandomSuffix int32

+ Rune int32

+ type ItemStringSpec struct

+ Enchant string

+ Name string

+ type ItemSwap struct

+ func (swap *ItemSwap) CalcStatChanges(slots []proto.ItemSlot) stats.Stats

+ func (swap *ItemSwap) GetItem(slot proto.ItemSlot) *Item

+ func (swap *ItemSwap) IsEnabled() bool

+ func (swap *ItemSwap) IsSwapped() bool

+ func (swap *ItemSwap) RegisterOnSwapItemForEffect(effectID int32, aura *Aura)

+ func (swap *ItemSwap) RegisterOnSwapItemForEffectWithPPMManager(effectID int32, ppm float64, ppmm *PPMManager, aura *Aura)

+ func (swap *ItemSwap) SwapItems(sim *Simulation, slots []proto.ItemSlot)

+ type ItemsTestGenerator struct

+ Debuffs *proto.Debuffs

+ Encounter *proto.Encounter

+ IsHealer bool

+ ItemFilter ItemFilter

+ PartyBuffs *proto.PartyBuffs

+ Player *proto.Player

+ RaidBuffs *proto.RaidBuffs

+ SimOptions *proto.SimOptions

+ func (generator *ItemsTestGenerator) GetTest(testIdx int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ func (generator *ItemsTestGenerator) NumTests() int

+ type MajorCooldown struct

+ Priority int32

+ ShouldActivate CooldownActivationCondition

+ Spell *Spell

+ Type CooldownType

+ func (mcd *MajorCooldown) Disable()

+ func (mcd *MajorCooldown) Enable()

+ func (mcd *MajorCooldown) GetTimings() []time.Duration

+ func (mcd *MajorCooldown) IsEnabled() bool

+ func (mcd *MajorCooldown) IsReady(sim *Simulation) bool

+ func (mcd *MajorCooldown) ReadyAt() time.Duration

+ func (mcd *MajorCooldown) TimeToNextCast(sim *Simulation) time.Duration

+ func (mcd *MajorCooldown) TimeToReady(sim *Simulation) time.Duration

+ func (mcd *MajorCooldown) TryActivate(sim *Simulation, character *Character) bool

+ type ManaCost struct

+ ResourceMetrics *ResourceMetrics

+ func (mc *ManaCost) CostFailureReason(sim *Simulation, spell *Spell) string

+ func (mc *ManaCost) IssueRefund(_ *Simulation, _ *Spell)

+ func (mc *ManaCost) MeetsRequirement(sim *Simulation, spell *Spell) bool

+ func (mc *ManaCost) SpendCost(sim *Simulation, spell *Spell)

+ type ManaCostOptions struct

+ BaseCost float64

+ FlatCost float64

+ Multiplier float64

+ type MeleeDamageCalculator func(attackPower float64, bonusWeaponDamage float64) float64

+ type OnCastComplete func(aura *Aura, sim *Simulation, spell *Spell)

+ type OnDamage func(aura *Aura, sim *Simulation, spell *Spell, result *SpellResult)

+ type OnDoneIteration func(aura *Aura, sim *Simulation)

+ type OnExpire func(aura *Aura, sim *Simulation)

+ type OnFocusGain func(sim *Simulation)

+ type OnGain func(aura *Aura, sim *Simulation)

+ type OnInit func(aura *Aura, sim *Simulation)

+ type OnPeriodicDamage func(aura *Aura, sim *Simulation, spell *Spell, result *SpellResult)

+ type OnPetDisable func(sim *Simulation)

+ type OnPetEnable func(sim *Simulation)

+ type OnRageChange func(aura *Aura, sim *Simulation, metrics *ResourceMetrics)

+ type OnReset func(aura *Aura, sim *Simulation)

+ type OnSnapshot func(sim *Simulation, target *Unit, dot *Dot, isRollover bool)

+ type OnSpellHit func(aura *Aura, sim *Simulation, spell *Spell, result *SpellResult)

+ type OnStacksChange func(aura *Aura, sim *Simulation, oldStacks int32, newStacks int32)

+ type OnStatsChange func(aura *Aura, sim *Simulation, oldStats stats.Stats, newStats stats.Stats)

+ type OnSwapItem func(*Simulation)

+ type OnTick func(sim *Simulation, target *Unit, dot *Dot)

+ type OutcomeApplier func(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ type PPMManager struct

+ func (ppmm *PPMManager) Chance(procMask ProcMask) float64

+ func (ppmm *PPMManager) Proc(sim *Simulation, procMask ProcMask, label string) bool

+ func (ppmm *PPMManager) ProcWithWeaponSpecials(sim *Simulation, procMask ProcMask, label string) bool

+ type Party struct

+ Index int

+ Pets []PetAgent

+ Players []Agent

+ PlayersAndPets []Agent

+ Raid *Raid

+ func NewParty(raid *Raid, index int, partyConfig *proto.Party) *Party

+ func (party *Party) AddStat(stat stats.Stat, amount float64)

+ func (party *Party) AddStats(newStats stats.Stats)

+ func (party *Party) GetMetrics() *proto.PartyMetrics

+ func (party *Party) GetPartyBuffs(basePartyBuffs *proto.PartyBuffs) *proto.PartyBuffs

+ func (party *Party) IsFull() bool

+ func (party *Party) Size() int

+ type PendingAction struct

+ CleanUp func(sim *Simulation)

+ NextActionAt time.Duration

+ OnAction func(sim *Simulation)

+ Priority ActionPriority

+ func NewDelayedAction(sim *Simulation, options DelayedActionOptions) *PendingAction

+ func NewPeriodicAction(sim *Simulation, options PeriodicActionOptions) *PendingAction

+ func StartDelayedAction(sim *Simulation, options DelayedActionOptions) *PendingAction

+ func StartPeriodicAction(sim *Simulation, options PeriodicActionOptions) *PendingAction

+ func (pa *PendingAction) Cancel(sim *Simulation)

+ type PeriodicActionOptions struct

+ CleanUp func(*Simulation)

+ NumTicks int

+ OnAction func(*Simulation)

+ Period time.Duration

+ Priority ActionPriority

+ TickImmediately bool

+ type Pet struct

+ OnPetDisable OnPetDisable

+ OnPetEnable OnPetEnable

+ Owner *Character

+ func NewPet(name string, owner *Character, baseStats stats.Stats, ...) Pet

+ func (at *Pet) GetActiveAuraWithTag(tag string) *Aura

+ func (at *Pet) GetAura(label string) *Aura

+ func (at *Pet) GetAuraByID(actionID ActionID) *Aura

+ func (at *Pet) GetAuras() []*Aura

+ func (at *Pet) GetAurasWithTag(tag string) []*Aura

+ func (at *Pet) GetIcdAuraByID(actionID ActionID) *Aura

+ func (at *Pet) HasActiveAura(label string) bool

+ func (at *Pet) HasActiveAuraWithTag(tag string) bool

+ func (at *Pet) HasActiveAuraWithTagExcludingAura(tag string, excludeAura *Aura) bool

+ func (at *Pet) HasAura(label string) bool

+ func (at *Pet) HasAuraWithTag(tag string) bool

+ func (at *Pet) NumActiveAurasWithTag(tag string) int32

+ func (at *Pet) OnCastComplete(sim *Simulation, spell *Spell)

+ func (at *Pet) OnHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) OnHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) OnPeriodicDamageDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) OnPeriodicDamageTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) OnPeriodicHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) OnPeriodicHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) OnRageChange(sim *Simulation, metrics *ResourceMetrics)

+ func (at *Pet) OnSpellHitDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) OnSpellHitTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Pet) RegisterResetEffect(resetEffect ResetEffect)

+ func (eb *Pet) AddComboPoints(sim *Simulation, pointsToAdd int32, metrics *ResourceMetrics)

+ func (eb *Pet) AddEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (eb *Pet) ComboPoints() int32

+ func (eb *Pet) CurrentEnergy() float64

+ func (eb *Pet) NextEnergyTickAt() time.Duration

+ func (eb *Pet) ResetEnergyTick(sim *Simulation)

+ func (eb *Pet) SpendComboPoints(sim *Simulation, metrics *ResourceMetrics)

+ func (eb *Pet) SpendEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Pet) AddFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Pet) CurrentFocus() float64

+ func (fb *Pet) CurrentFocusPerTick() float64

+ func (fb *Pet) SpendFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Pet) CurrentHealth() float64

+ func (hb *Pet) CurrentHealthPercent() float64

+ func (hb *Pet) GainHealth(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Pet) MaxHealth() float64

+ func (hb *Pet) RemoveHealth(sim *Simulation, amount float64)

+ func (mb *Pet) EndOOMEvent(sim *Simulation)

+ func (mb *Pet) IsOOM() bool

+ func (mb *Pet) StartOOMEvent(sim *Simulation, requiredMana float64)

+ func (mcdm *Pet) AddMajorCooldown(mcd MajorCooldown)

+ func (mcdm *Pet) GetInitialMajorCooldown(actionID ActionID) MajorCooldown

+ func (mcdm *Pet) GetMajorCooldown(actionID ActionID) *MajorCooldown

+ func (mcdm *Pet) GetMajorCooldownIDs() []*proto.ActionID

+ func (mcdm *Pet) GetMajorCooldownIgnoreTag(actionID ActionID) *MajorCooldown

+ func (mcdm *Pet) GetMajorCooldowns() []*MajorCooldown

+ func (mcdm *Pet) TryUseCooldowns(sim *Simulation)

+ func (mcdm *Pet) UpdateMajorCooldowns()

+ func (pet *Pet) AddPartyBuffs(_ *proto.PartyBuffs)

+ func (pet *Pet) AddRaidBuffs(_ *proto.RaidBuffs)

+ func (pet *Pet) ApplyRunes()

+ func (pet *Pet) ApplyTalents()

+ func (pet *Pet) Disable(sim *Simulation)

+ func (pet *Pet) Enable(sim *Simulation, petAgent PetAgent)

+ func (pet *Pet) EnableDynamicMeleeSpeed(inheritance PetMeleeSpeedInheritance)

+ func (pet *Pet) EnableDynamicStats(inheritance PetStatInheritance)

+ func (pet *Pet) EnableWithTimeout(sim *Simulation, petAgent PetAgent, petDuration time.Duration)

+ func (pet *Pet) GetCharacter() *Character

+ func (pet *Pet) IsGuardian() bool

+ func (pet *Pet) OnGCDReady(_ *Simulation)

+ func (rb *Pet) AddRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (rb *Pet) CurrentRage() float64

+ func (rb *Pet) SpendRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ type PetAgent interface

+ GetPet func() *Pet

+ type PetMeleeSpeedInheritance func(amount float64)

+ type PetStatInheritance func(ownerStats stats.Stats) stats.Stats

+ type PostFinalizeEffect func()

+ type PowerBarType int

+ const EnergyBar

+ const ManaBar

+ const RageBar

+ type PrepullAction struct

+ Action func(*Simulation)

+ DoAt time.Duration

+ type PresetTarget struct

+ AI AIFactory

+ Config *proto.Target

+ PathPrefix string

+ func GetPresetTargetWithID(id int32) *PresetTarget

+ func GetPresetTargetWithPath(path string) *PresetTarget

+ func (pt PresetTarget) Path() string

+ func (pt PresetTarget) ToProto() *proto.PresetTarget

+ type PresimOptions struct

+ OnPresimResult func(presimResult *proto.UnitMetrics, iterations int32, duration time.Duration) bool

+ SetPresimPlayerOptions func(player *proto.Player)

+ type Presimmer interface

+ GetPresimOptions func(*proto.Player) *PresimOptions

+ type ProcHandler func(sim *Simulation, spell *Spell, result *SpellResult)

+ type ProcMask uint32

+ const ProcMaskEmpty

+ const ProcMaskMeleeMHAuto

+ const ProcMaskMeleeMHSpecial

+ const ProcMaskMeleeOHAuto

+ const ProcMaskMeleeOHSpecial

+ const ProcMaskNotInSpellbook

+ const ProcMaskProc

+ const ProcMaskRangedAuto

+ const ProcMaskRangedSpecial

+ const ProcMaskSpellDamage

+ const ProcMaskSpellHealing

+ const ProcMaskSuppressedExtraAttackAura

+ const ProcMaskSuppressedProc

+ const ProcMaskUnknown

+ const ProcMaskWeaponProc

+ func (pm ProcMask) Matches(other ProcMask) bool

+ type ProcTrigger struct

+ ActionID ActionID

+ Callback AuraCallback

+ Duration time.Duration

+ Handler ProcHandler

+ Harmful bool

+ ICD time.Duration

+ Name string

+ Outcome HitOutcome

+ PPM float64

+ ProcChance float64

+ ProcMask ProcMask

+ ProcMaskExclude ProcMask

+ SpellFlags SpellFlag

+ type RageBarOptions struct

+ MHSwingSpeed float64

+ OHSwingSpeed float64

+ RageMultiplier float64

+ StartingRage float64

+ type RageCost struct

+ Refund float64

+ RefundMetrics *ResourceMetrics

+ ResourceMetrics *ResourceMetrics

+ func (rc *RageCost) CostFailureReason(sim *Simulation, spell *Spell) string

+ func (rc *RageCost) IssueRefund(sim *Simulation, spell *Spell)

+ func (rc *RageCost) MeetsRequirement(_ *Simulation, spell *Spell) bool

+ func (rc *RageCost) SpendCost(sim *Simulation, spell *Spell)

+ type RageCostOptions struct

+ Cost float64

+ Refund float64

+ RefundMetrics *ResourceMetrics

+ type Raid struct

+ AllPlayerUnits []*Unit

+ AllUnits []*Unit

+ Parties []*Party

+ func NewRaid(raidConfig *proto.Raid) *Raid

+ func (raid *Raid) AddStats(s stats.Stats)

+ func (raid *Raid) GetActiveUnits() []*Unit

+ func (raid *Raid) GetFirstEmptyRaidIndex() (*Party, int)

+ func (raid *Raid) GetFirstNPlayersOrPets(n int32) []*Unit

+ func (raid *Raid) GetFirstTargetDummy() *TargetDummy

+ func (raid *Raid) GetMetrics() *proto.RaidMetrics

+ func (raid *Raid) GetPlayerFromUnit(unit *Unit) Agent

+ func (raid *Raid) GetPlayerFromUnitIndex(unitIndex int32) Agent

+ func (raid *Raid) GetPlayerParty(unit *Unit) *Party

+ func (raid *Raid) GetPlayersOfClass(class proto.Class) []Agent

+ func (raid *Raid) GetRaidBuffs(baseRaidBuffs *proto.RaidBuffs) *proto.RaidBuffs

+ func (raid *Raid) Size() int

+ type Rand interface

+ GetSeed func() int64

+ Next func() uint64

+ NextFloat64 func() float64

+ Seed func(int64)

+ type RandomSuffix struct

+ ID int32

+ Name string

+ Stats stats.Stats

+ func RandomSuffixFromProto(pData *proto.ItemRandomSuffix) RandomSuffix

+ type ReplaceMHSwing func(sim *Simulation, mhSwingSpell *Spell) *Spell

+ type ResetEffect func(*Simulation)

+ type ResourceKey struct

+ ActionID ActionID

+ Type proto.ResourceType

+ type ResourceMetrics struct

+ ActionID ActionID

+ ActualGain float64

+ ActualGainFromPreviousIterations float64

+ Events int32

+ EventsFromPreviousIterations int32

+ Gain float64

+ Type proto.ResourceType

+ func (resourceMetrics *ResourceMetrics) ActualGainForCurrentIteration() float64

+ func (resourceMetrics *ResourceMetrics) AddEvent(gain float64, actualGain float64)

+ func (resourceMetrics *ResourceMetrics) EventsForCurrentIteration() int32

+ func (resourceMetrics *ResourceMetrics) ToProto() *proto.ResourceMetrics

+ type RotationCastsTestGenerator struct

+ Debuffs *proto.Debuffs

+ Encounter *proto.Encounter

+ PartyBuffs *proto.PartyBuffs

+ Player *proto.Player

+ RaidBuffs *proto.RaidBuffs

+ SimOptions *proto.SimOptions

+ SpecOptions []SpecOptionsCombo

+ func (generator *RotationCastsTestGenerator) GetTest(testIdx int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ func (generator *RotationCastsTestGenerator) NumTests() int

+ type RotationCombo struct

+ Label string

+ Rotation *proto.APLRotation

+ func GetAplRotation(dir string, file string) RotationCombo

+ type Rune struct

+ ID int32

+ func RuneFromProto(pData *proto.SimRune) Rune

+ type SettingsCombos struct

+ Buffs []BuffsCombo

+ Class proto.Class

+ Cooldowns *proto.Cooldowns

+ Encounters []EncounterCombo

+ GearSets []GearSetCombo

+ IsHealer bool

+ Level int32

+ Races []proto.Race

+ Rotations []RotationCombo

+ SimOptions *proto.SimOptions

+ SpecOptions []SpecOptionsCombo

+ TalentSets []TalentsCombo

+ func (combos *SettingsCombos) GetTest(testIdx int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ func (combos *SettingsCombos) NumTests() int

+ type Shield struct

+ Spell *Spell

+ func (shield *Shield) Apply(sim *Simulation, shieldAmount float64)

+ type ShieldArray []*Shield

+ func (shields ShieldArray) Get(target *Unit) *Shield

+ type ShieldConfig struct

+ SelfOnly bool

+ Spell *Spell

+ type Simulation struct

+ CurrentTime time.Duration

+ Duration time.Duration

+ Log func(string, ...interface{})

+ NeedsInput bool

+ Options *proto.SimOptions

+ ProgressReport func(*proto.ProgressMetrics)

+ func NewSim(rsr *proto.RaidSimRequest) *Simulation

+ func (sim *Simulation) AddPendingAction(pa *PendingAction)

+ func (sim *Simulation) AddTask(task Task)

+ func (sim *Simulation) Cleanup()

+ func (sim *Simulation) GetRemainingDuration() time.Duration

+ func (sim *Simulation) GetRemainingDurationPercent() float64

+ func (sim *Simulation) IsExecutePhase20() bool

+ func (sim *Simulation) IsExecutePhase25() bool

+ func (sim *Simulation) IsExecutePhase35() bool

+ func (sim *Simulation) PrePull()

+ func (sim *Simulation) Proc(p float64, label string) bool

+ func (sim *Simulation) RandomExpFloat(label string) float64

+ func (sim *Simulation) RandomFloat(label string) float64

+ func (sim *Simulation) RegisterExecutePhaseCallback(callback func(sim *Simulation, isExecute int32))

+ func (sim *Simulation) RemoveTask(task Task)

+ func (sim *Simulation) RescheduleTask(taskTime time.Duration)

+ func (sim *Simulation) Reseed(seed int64)

+ func (sim *Simulation) Reset()

+ func (sim *Simulation) Roll(min float64, max float64) float64

+ func (sim *Simulation) RollWithLabel(min float64, max float64, label string) float64

+ func (sim *Simulation) Step() bool

+ type SingleCharacterStatsTestGenerator struct

+ Name string

+ Request *proto.ComputeStatsRequest

+ func (generator *SingleCharacterStatsTestGenerator) GetTest(_ int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ func (generator *SingleCharacterStatsTestGenerator) NumTests() int

+ type SingleDpsTestGenerator struct

+ Name string

+ Request *proto.RaidSimRequest

+ func (generator *SingleDpsTestGenerator) GetTest(_ int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ func (generator *SingleDpsTestGenerator) NumTests() int

+ type SingleStatWeightsTestGenerator struct

+ Name string

+ Request *proto.StatWeightsRequest

+ func (generator *SingleStatWeightsTestGenerator) GetTest(_ int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ func (generator *SingleStatWeightsTestGenerator) NumTests() int

+ type SpecOptionsCombo struct

+ Label string

+ SpecOptions interface{}

+ type SpecSetter func(*proto.Player, interface{})

+ type Spell struct

+ ApplyEffects ApplySpellResults

+ BonusArmorPenRating float64

+ BonusCritRating float64

+ BonusExpertiseRating float64

+ BonusHitRating float64

+ BonusSpellPower float64

+ CD Cooldown

+ CastTimeMultiplier float64

+ CastType proto.CastType

+ CdSpell *Spell

+ Cost SpellCost

+ CostMultiplier float64

+ CritMultiplier float64

+ CurCast Cast

+ DamageMultiplier float64

+ DamageMultiplierAdditive float64

+ DefaultCast Cast

+ ExtraCastCondition CanCastCondition

+ Flags SpellFlag

+ FlatThreatBonus float64

+ IsMultischool bool

+ MissileSpeed float64

+ ProcMask ProcMask

+ RelatedAuras []AuraArray

+ ResourceMetrics *ResourceMetrics

+ SchoolBaseIndices []stats.SchoolIndex

+ SchoolIndex stats.SchoolIndex

+ SharedCD Cooldown

+ SpellCode int32

+ SpellMetrics []SpellMetrics

+ SpellSchool SpellSchool

+ ThreatMultiplier float64

+ Unit *Unit

+ func (spell *Spell) AOEDot() *Dot

+ func (spell *Spell) AOEHot() *Dot

+ func (spell *Spell) ApplyAOEThreat(threatAmount float64)

+ func (spell *Spell) ApplyAOEThreatIgnoreMultipliers(threatAmount float64)

+ func (spell *Spell) ApplyCostModifiers(cost float64) float64

+ func (spell *Spell) ApplyPostOutcomeDamageModifiers(sim *Simulation, result *SpellResult)

+ func (spell *Spell) AttackerDamageMultiplier(attackTable *AttackTable) float64

+ func (spell *Spell) BonusWeaponDamage() float64

+ func (spell *Spell) CalcAndDealDamage(sim *Simulation, target *Unit, baseDamage float64, ...) *SpellResult

+ func (spell *Spell) CalcAndDealHealing(sim *Simulation, target *Unit, baseHealing float64, ...) *SpellResult

+ func (spell *Spell) CalcAndDealOutcome(sim *Simulation, target *Unit, outcomeApplier OutcomeApplier) *SpellResult

+ func (spell *Spell) CalcAndDealPeriodicDamage(sim *Simulation, target *Unit, baseDamage float64, ...) *SpellResult

+ func (spell *Spell) CalcAndDealPeriodicHealing(sim *Simulation, target *Unit, baseHealing float64, ...) *SpellResult

+ func (spell *Spell) CalcDamage(sim *Simulation, target *Unit, baseDamage float64, ...) *SpellResult

+ func (spell *Spell) CalcHealing(sim *Simulation, target *Unit, baseHealing float64, ...) *SpellResult

+ func (spell *Spell) CalcOutcome(sim *Simulation, target *Unit, outcomeApplier OutcomeApplier) *SpellResult

+ func (spell *Spell) CalcPeriodicDamage(sim *Simulation, target *Unit, baseDamage float64, ...) *SpellResult

+ func (spell *Spell) CanCast(sim *Simulation, target *Unit) bool

+ func (spell *Spell) Cast(sim *Simulation, target *Unit) bool

+ func (spell *Spell) CastTime() time.Duration

+ func (spell *Spell) CasterHealingMultiplier() float64

+ func (spell *Spell) ComboPointMetrics() *ResourceMetrics

+ func (spell *Spell) CurCPM(sim *Simulation) float64

+ func (spell *Spell) CurDamagePerCast() float64

+ func (spell *Spell) CurDot() *Dot

+ func (spell *Spell) CurHot() *Dot

+ func (spell *Spell) DealDamage(sim *Simulation, result *SpellResult)

+ func (spell *Spell) DealHealing(sim *Simulation, result *SpellResult)

+ func (spell *Spell) DealOutcome(sim *Simulation, result *SpellResult)

+ func (spell *Spell) DealPeriodicDamage(sim *Simulation, result *SpellResult)

+ func (spell *Spell) DealPeriodicHealing(sim *Simulation, result *SpellResult)

+ func (spell *Spell) DisposeResult(result *SpellResult)

+ func (spell *Spell) Dot(target *Unit) *Dot

+ func (spell *Spell) EffectiveCastTime() time.Duration

+ func (spell *Spell) EnergyMetrics() *ResourceMetrics

+ func (spell *Spell) ExpectedInitialDamage(sim *Simulation, target *Unit) float64

+ func (spell *Spell) ExpectedTickDamage(sim *Simulation, target *Unit) float64

+ func (spell *Spell) ExpectedTickDamageFromCurrentSnapshot(sim *Simulation, target *Unit) float64

+ func (spell *Spell) ExpertisePercentage() float64

+ func (spell *Spell) HealingCritChance() float64

+ func (spell *Spell) HealingCritCheck(sim *Simulation) bool

+ func (spell *Spell) HealingPower(target *Unit) float64

+ func (spell *Spell) HealthMetrics(target *Unit) *ResourceMetrics

+ func (spell *Spell) Hot(target *Unit) *Dot

+ func (spell *Spell) IsMH() bool

+ func (spell *Spell) IsMelee() bool

+ func (spell *Spell) IsOH() bool

+ func (spell *Spell) IsReady(sim *Simulation) bool

+ func (spell *Spell) IssueRefund(sim *Simulation)

+ func (spell *Spell) MagicCritCheck(sim *Simulation, target *Unit) bool

+ func (spell *Spell) MagicHitCheck(sim *Simulation, attackTable *AttackTable) bool

+ func (spell *Spell) MeleeAttackPower() float64

+ func (spell *Spell) NewResult(target *Unit) *SpellResult

+ func (spell *Spell) OutcomeAlwaysHit(_ *Simulation, result *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeAlwaysMiss(_ *Simulation, result *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeEnemyMeleeWhite(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeExpectedMagicAlwaysHit(_ *Simulation, _ *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeExpectedMagicCrit(_ *Simulation, result *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeExpectedMagicHit(_ *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeExpectedMagicHitAndCrit(_ *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeExpectedTick(_ *Simulation, _ *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeHealing(_ *Simulation, result *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeHealingCrit(sim *Simulation, result *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeMagicCrit(sim *Simulation, result *SpellResult, _ *AttackTable)

+ func (spell *Spell) OutcomeMagicHit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMagicHitAndCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeSpecialCritOnly(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeSpecialHit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeSpecialHitAndCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeSpecialNoBlockDodgeParry(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeSpecialNoBlockDodgeParryNoCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeWeaponSpecialHitAndCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeWeaponSpecialNoCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeMeleeWhite(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeRangedCritOnly(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeRangedHit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeRangedHitAndCrit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeRangedHitAndCritNoBlock(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) OutcomeTickMagicHit(sim *Simulation, result *SpellResult, attackTable *AttackTable)

+ func (spell *Spell) PhysicalCritChance(attackTable *AttackTable) float64

+ func (spell *Spell) PhysicalCritCheck(sim *Simulation, attackTable *AttackTable) bool

+ func (spell *Spell) PhysicalHitChance(attackTable *AttackTable) float64

+ func (spell *Spell) RangedAttackPower(target *Unit) float64

+ func (spell *Spell) ReadyAt() time.Duration

+ func (spell *Spell) ResistanceMultiplier(sim *Simulation, isPeriodic bool, attackTable *AttackTable) (float64, HitOutcome)

+ func (spell *Spell) SelfHot() *Dot

+ func (spell *Spell) SelfShield() *Shield

+ func (spell *Spell) SetMetricsSplit(splitIdx int32)

+ func (spell *Spell) SetSchool(schoolIndex stats.SchoolIndex)

+ func (spell *Spell) Shield(target *Unit) *Shield

+ func (spell *Spell) ShouldRefreshExclusiveEffects(sim *Simulation, target *Unit, refreshWindow time.Duration) bool

+ func (spell *Spell) SkipCastAndApplyEffects(sim *Simulation, target *Unit)

+ func (spell *Spell) SpellChanceToMiss(attackTable *AttackTable) float64

+ func (spell *Spell) SpellCritChance(target *Unit) float64

+ func (spell *Spell) SpellDamage() float64

+ func (spell *Spell) SpellHitChance(target *Unit) float64

+ func (spell *Spell) SpellPower() float64

+ func (spell *Spell) SpellSchoolPower() float64

+ func (spell *Spell) TargetDamageMultiplier(attackTable *AttackTable, isPeriodic bool) float64

+ func (spell *Spell) ThreatFromDamage(outcome HitOutcome, damage float64) float64

+ func (spell *Spell) TimeToReady(sim *Simulation) time.Duration

+ func (spell *Spell) TravelTime() time.Duration

+ func (spell *Spell) WaitTravelTime(sim *Simulation, callback func(*Simulation))

+ type SpellConfig struct

+ ApplyEffects ApplySpellResults

+ BaseCost float64

+ BonusArmorPenRating float64

+ BonusCritRating float64

+ BonusExpertiseRating float64

+ BonusHitRating float64

+ BonusSpellPower float64

+ Cast CastConfig

+ CastType proto.CastType

+ CritMultiplier float64

+ DamageMultiplier float64

+ DamageMultiplierAdditive float64

+ Dot DotConfig

+ EnergyCost EnergyCostOptions

+ ExpectedInitialDamage ExpectedDamageCalculator

+ ExpectedTickDamage ExpectedDamageCalculator

+ ExtraCastCondition CanCastCondition

+ Flags SpellFlag

+ FlatThreatBonus float64

+ FocusCost FocusCostOptions

+ Hot DotConfig

+ ManaCost ManaCostOptions

+ MetricSplits int

+ MissileSpeed float64

+ ProcMask ProcMask

+ RageCost RageCostOptions

+ Rank int

+ RelatedAuras []AuraArray

+ RequiredLevel int

+ Shield ShieldConfig

+ SpellCode int32

+ SpellSchool SpellSchool

+ ThreatMultiplier float64

+ type SpellCost interface

+ CostFailureReason func(*Simulation, *Spell) string

+ IssueRefund func(*Simulation, *Spell)

+ MeetsRequirement func(*Simulation, *Spell) bool

+ SpendCost func(*Simulation, *Spell)

+ type SpellFlag uint32

+ const SpellFlagAPL

+ const SpellFlagAgentReserved1

+ const SpellFlagAgentReserved2

+ const SpellFlagAgentReserved3

+ const SpellFlagAgentReserved4

+ const SpellFlagApplyArmorReduction

+ const SpellFlagBinary

+ const SpellFlagCannotBeDodged

+ const SpellFlagCastTimeNoGCD

+ const SpellFlagChanneled

+ const SpellFlagCombatPotion

+ const SpellFlagDisease

+ const SpellFlagEncounterOnly

+ const SpellFlagHauntSE

+ const SpellFlagHelpful

+ const SpellFlagIgnoreAttackerModifiers

+ const SpellFlagIgnoreModifiers

+ const SpellFlagIgnoreResists

+ const SpellFlagIgnoreTargetModifiers

+ const SpellFlagIncludeTargetBonusDamage

+ const SpellFlagMCD

+ const SpellFlagMeleeMetrics

+ const SpellFlagNoLogs

+ const SpellFlagNoMetrics

+ const SpellFlagNoOnCastComplete

+ const SpellFlagNoOnDamageDealt

+ const SpellFlagNone

+ const SpellFlagPoison

+ const SpellFlagPotion

+ const SpellFlagPrepullOnly

+ const SpellFlagPrepullPotion

+ const SpellFlagPureDot

+ const SpellFlagResetAttackSwing

+ func (se SpellFlag) Matches(other SpellFlag) bool

+ type SpellMetrics struct

+ Blocks int32

+ Casts int32

+ Crits int32

+ Crushes int32

+ Dodges int32

+ Glances int32

+ Hits int32

+ Misses int32

+ Parries int32

+ TotalCastTime time.Duration

+ TotalDamage float64

+ TotalHealing float64

+ TotalShielding float64

+ TotalThreat float64

+ type SpellRegisteredHandler func(spell *Spell)

+ type SpellResult struct

+ Damage float64

+ Outcome HitOutcome

+ PreOutcomeDamage float64

+ ResistanceMultiplier float64

+ Target *Unit

+ Threat float64

+ func (result *SpellResult) DamageString() string

+ func (result *SpellResult) DidCrit() bool

+ func (result *SpellResult) HealingString() string

+ func (result *SpellResult) Landed() bool

+ type SpellSchool byte

+ func SpellSchoolFromIndex(schoolIndex stats.SchoolIndex) SpellSchool

+ func SpellSchoolFromProto(p proto.SpellSchool) SpellSchool

+ func (ss SpellSchool) GetSchoolIndex() stats.SchoolIndex

+ func (ss SpellSchool) Matches(other SpellSchool) bool

+ type SpiritManaRegenPerSecond func() float64

+ type SplitMix64 struct

+ func NewSplitMix(seed uint64) *SplitMix64

+ func (sm *SplitMix64) GetSeed() int64

+ func (sm *SplitMix64) Int63() int64

+ func (sm *SplitMix64) Next() uint64

+ func (sm *SplitMix64) NextFloat64() float64

+ func (sm *SplitMix64) Seed(s int64)

+ func (sm *SplitMix64) Uint64() uint64

+ type StackingStatAura struct

+ Aura Aura

+ BonusPerStack stats.Stats

+ type StatWeightValues struct

+ EpValues UnitStats

+ EpValuesStdev UnitStats

+ Weights UnitStats

+ WeightsStdev UnitStats

+ func NewStatWeightValues() StatWeightValues

+ func (swv *StatWeightValues) ToProto() *proto.StatWeightValues

+ type StatWeightsResult struct

+ Dps StatWeightValues

+ Dtps StatWeightValues

+ Hps StatWeightValues

+ PDeath StatWeightValues

+ Tmi StatWeightValues

+ Tps StatWeightValues

+ func CalcStatWeight(swr *proto.StatWeightsRequest, referenceStat stats.Stat, ...) *StatWeightsResult

+ func NewStatWeightsResult() *StatWeightsResult

+ func (swr *StatWeightsResult) ToProto() *proto.StatWeightsResult

+ type SubGenerator struct

+ type SubstitutionComboChecker map[string]struct

+ func (ic *SubstitutionComboChecker) HasCombo(replacements equipmentSubstitution) bool

+ type TalentsCombo struct

+ Label string

+ Talents string

+ type Target struct

+ AI TargetAI

+ func NewTarget(options *proto.Target, targetIndex int32) *Target

+ func (at *Target) GetActiveAuraWithTag(tag string) *Aura

+ func (at *Target) GetAura(label string) *Aura

+ func (at *Target) GetAuraByID(actionID ActionID) *Aura

+ func (at *Target) GetAuras() []*Aura

+ func (at *Target) GetAurasWithTag(tag string) []*Aura

+ func (at *Target) GetIcdAuraByID(actionID ActionID) *Aura

+ func (at *Target) HasActiveAura(label string) bool

+ func (at *Target) HasActiveAuraWithTag(tag string) bool

+ func (at *Target) HasActiveAuraWithTagExcludingAura(tag string, excludeAura *Aura) bool

+ func (at *Target) HasAura(label string) bool

+ func (at *Target) HasAuraWithTag(tag string) bool

+ func (at *Target) NumActiveAurasWithTag(tag string) int32

+ func (at *Target) OnCastComplete(sim *Simulation, spell *Spell)

+ func (at *Target) OnHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) OnHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) OnPeriodicDamageDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) OnPeriodicDamageTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) OnPeriodicHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) OnPeriodicHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) OnRageChange(sim *Simulation, metrics *ResourceMetrics)

+ func (at *Target) OnSpellHitDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) OnSpellHitTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Target) RegisterResetEffect(resetEffect ResetEffect)

+ func (eb *Target) AddComboPoints(sim *Simulation, pointsToAdd int32, metrics *ResourceMetrics)

+ func (eb *Target) AddEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (eb *Target) ComboPoints() int32

+ func (eb *Target) CurrentEnergy() float64

+ func (eb *Target) NextEnergyTickAt() time.Duration

+ func (eb *Target) ResetEnergyTick(sim *Simulation)

+ func (eb *Target) SpendComboPoints(sim *Simulation, metrics *ResourceMetrics)

+ func (eb *Target) SpendEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Target) AddFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Target) CurrentFocus() float64

+ func (fb *Target) CurrentFocusPerTick() float64

+ func (fb *Target) SpendFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Target) CurrentHealth() float64

+ func (hb *Target) CurrentHealthPercent() float64

+ func (hb *Target) GainHealth(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Target) MaxHealth() float64

+ func (hb *Target) RemoveHealth(sim *Simulation, amount float64)

+ func (mb *Target) EndOOMEvent(sim *Simulation)

+ func (mb *Target) IsOOM() bool

+ func (mb *Target) StartOOMEvent(sim *Simulation, requiredMana float64)

+ func (rb *Target) AddRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (rb *Target) CurrentRage() float64

+ func (rb *Target) SpendRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (target *Target) AddPartyBuffs(_ *proto.PartyBuffs)

+ func (target *Target) AddRaidBuffs(_ *proto.RaidBuffs)

+ func (target *Target) ApplyRunes()

+ func (target *Target) ApplyTalents()

+ func (target *Target) ExecuteCustomRotation(sim *Simulation)

+ func (target *Target) GetCharacter() *Character

+ func (target *Target) GetMetricsProto() *proto.UnitMetrics

+ func (target *Target) Initialize()

+ func (target *Target) NextTarget() *Target

+ func (target *Target) Reset(sim *Simulation)

+ type TargetAI interface

+ ExecuteCustomRotation func(*Simulation)

+ Initialize func(*Target, *proto.Target)

+ Reset func(*Simulation)

+ type TargetDummy struct

+ func NewTargetDummy(dummyIndex int, party *Party, partyIndex int) *TargetDummy

+ func (at *TargetDummy) GetActiveAuraWithTag(tag string) *Aura

+ func (at *TargetDummy) GetAura(label string) *Aura

+ func (at *TargetDummy) GetAuraByID(actionID ActionID) *Aura

+ func (at *TargetDummy) GetAuras() []*Aura

+ func (at *TargetDummy) GetAurasWithTag(tag string) []*Aura

+ func (at *TargetDummy) GetIcdAuraByID(actionID ActionID) *Aura

+ func (at *TargetDummy) HasActiveAura(label string) bool

+ func (at *TargetDummy) HasActiveAuraWithTag(tag string) bool

+ func (at *TargetDummy) HasActiveAuraWithTagExcludingAura(tag string, excludeAura *Aura) bool

+ func (at *TargetDummy) HasAura(label string) bool

+ func (at *TargetDummy) HasAuraWithTag(tag string) bool

+ func (at *TargetDummy) NumActiveAurasWithTag(tag string) int32

+ func (at *TargetDummy) OnCastComplete(sim *Simulation, spell *Spell)

+ func (at *TargetDummy) OnHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) OnHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) OnPeriodicDamageDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) OnPeriodicDamageTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) OnPeriodicHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) OnPeriodicHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) OnRageChange(sim *Simulation, metrics *ResourceMetrics)

+ func (at *TargetDummy) OnSpellHitDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) OnSpellHitTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *TargetDummy) RegisterResetEffect(resetEffect ResetEffect)

+ func (eb *TargetDummy) AddComboPoints(sim *Simulation, pointsToAdd int32, metrics *ResourceMetrics)

+ func (eb *TargetDummy) AddEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (eb *TargetDummy) ComboPoints() int32

+ func (eb *TargetDummy) CurrentEnergy() float64

+ func (eb *TargetDummy) NextEnergyTickAt() time.Duration

+ func (eb *TargetDummy) ResetEnergyTick(sim *Simulation)

+ func (eb *TargetDummy) SpendComboPoints(sim *Simulation, metrics *ResourceMetrics)

+ func (eb *TargetDummy) SpendEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *TargetDummy) AddFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *TargetDummy) CurrentFocus() float64

+ func (fb *TargetDummy) CurrentFocusPerTick() float64

+ func (fb *TargetDummy) SpendFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *TargetDummy) CurrentHealth() float64

+ func (hb *TargetDummy) CurrentHealthPercent() float64

+ func (hb *TargetDummy) GainHealth(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *TargetDummy) MaxHealth() float64

+ func (hb *TargetDummy) RemoveHealth(sim *Simulation, amount float64)

+ func (mb *TargetDummy) EndOOMEvent(sim *Simulation)

+ func (mb *TargetDummy) IsOOM() bool

+ func (mb *TargetDummy) StartOOMEvent(sim *Simulation, requiredMana float64)

+ func (mcdm *TargetDummy) AddMajorCooldown(mcd MajorCooldown)

+ func (mcdm *TargetDummy) GetInitialMajorCooldown(actionID ActionID) MajorCooldown

+ func (mcdm *TargetDummy) GetMajorCooldown(actionID ActionID) *MajorCooldown

+ func (mcdm *TargetDummy) GetMajorCooldownIDs() []*proto.ActionID

+ func (mcdm *TargetDummy) GetMajorCooldownIgnoreTag(actionID ActionID) *MajorCooldown

+ func (mcdm *TargetDummy) GetMajorCooldowns() []*MajorCooldown

+ func (mcdm *TargetDummy) TryUseCooldowns(sim *Simulation)

+ func (mcdm *TargetDummy) UpdateMajorCooldowns()

+ func (rb *TargetDummy) AddRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (rb *TargetDummy) CurrentRage() float64

+ func (rb *TargetDummy) SpendRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (td *TargetDummy) AddPartyBuffs(partyBuffs *proto.PartyBuffs)

+ func (td *TargetDummy) AddRaidBuffs(raidBuffs *proto.RaidBuffs)

+ func (td *TargetDummy) ApplyRunes()

+ func (td *TargetDummy) ApplyTalents()

+ func (td *TargetDummy) ExecuteCustomRotation(sim *Simulation)

+ func (td *TargetDummy) GetCharacter() *Character

+ func (td *TargetDummy) Initialize()

+ func (td *TargetDummy) Reset(sim *Simulation)

+ type TargetedActionMetrics struct

+ Blocks int32

+ CastTime time.Duration

+ Casts int32

+ Crits int32

+ Damage float64

+ Dodges int32

+ Glances int32

+ Healing float64

+ Hits int32

+ Misses int32

+ Parries int32

+ Shielding float64

+ Threat float64

+ UnitIndex int32

+ func (tam *TargetedActionMetrics) ToProto() *proto.TargetedActionMetrics

+ type Task interface

+ RunTask func(sim *Simulation) time.Duration

+ type TestGenerator interface

+ GetTest func(testIdx int) (string, *proto.ComputeStatsRequest, *proto.StatWeightsRequest, ...)

+ NumTests func() int

+ func FullCharacterTestSuiteGenerator(configs []CharacterSuiteConfig) []TestGenerator

+ type Timer time.Duration

+ func (timer *Timer) IsReady(sim *Simulation) bool

+ func (timer *Timer) ReadyAt() time.Duration

+ func (timer *Timer) Reset()

+ func (timer *Timer) Set(t time.Duration)

+ func (timer *Timer) TimeToReady(sim *Simulation) time.Duration

+ type Unit struct

+ AttackTables []map[proto.CastType]*AttackTable

+ AutoAttacks AutoAttacks

+ CastSpeed float64

+ ChannelClipDelay time.Duration

+ ChanneledDot *Dot

+ CurrentTarget *Unit

+ DistanceFromTarget float64

+ DynamicDamageTakenModifiers []DynamicDamageTakenModifier

+ DynamicMeleeSpeedPets []*Pet

+ DynamicStatsPets []*Pet

+ Env *Environment

+ GCD *Timer

+ Hardcast Hardcast

+ Index int32

+ Label string

+ Level int32

+ Metrics UnitMetrics

+ MobType proto.MobType

+ Moving bool

+ PetAgents []PetAgent

+ PseudoStats stats.PseudoStats

+ ReactionTime time.Duration

+ Rotation *APLRotation

+ Spellbook []*Spell

+ StartDistanceFromTarget float64

+ Type UnitType

+ UnitIndex int32

+ func (at *Unit) GetActiveAuraWithTag(tag string) *Aura

+ func (at *Unit) GetAura(label string) *Aura

+ func (at *Unit) GetAuraByID(actionID ActionID) *Aura

+ func (at *Unit) GetAuras() []*Aura

+ func (at *Unit) GetAurasWithTag(tag string) []*Aura

+ func (at *Unit) GetIcdAuraByID(actionID ActionID) *Aura

+ func (at *Unit) GetMetricsProto() []*proto.AuraMetrics

+ func (at *Unit) HasActiveAura(label string) bool

+ func (at *Unit) HasActiveAuraWithTag(tag string) bool

+ func (at *Unit) HasActiveAuraWithTagExcludingAura(tag string, excludeAura *Aura) bool

+ func (at *Unit) HasAura(label string) bool

+ func (at *Unit) HasAuraWithTag(tag string) bool

+ func (at *Unit) NumActiveAurasWithTag(tag string) int32

+ func (at *Unit) OnCastComplete(sim *Simulation, spell *Spell)

+ func (at *Unit) OnHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) OnHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) OnPeriodicDamageDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) OnPeriodicDamageTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) OnPeriodicHealDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) OnPeriodicHealTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) OnRageChange(sim *Simulation, metrics *ResourceMetrics)

+ func (at *Unit) OnSpellHitDealt(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) OnSpellHitTaken(sim *Simulation, spell *Spell, result *SpellResult)

+ func (at *Unit) RegisterResetEffect(resetEffect ResetEffect)

+ func (caster *Unit) GetEnemyExclusiveCategories(category string) ExclusiveCategoryArray

+ func (caster *Unit) NewEnemyAuraArray(makeAura func(*Unit, int32) *Aura) AuraArray

+ func (caster *Unit) NewEnemyExclusiveCategoryArray(makeExclusiveCategory func(*Unit) *ExclusiveCategory) ExclusiveCategoryArray

+ func (caster *Unit) NewPartyAuraArray(makeAura func(*Unit) *Aura) AuraArray

+ func (caster *Unit) NewRaidAuraArray(makeAura func(*Unit) *Aura) AuraArray

+ func (eb *Unit) AddComboPoints(sim *Simulation, pointsToAdd int32, metrics *ResourceMetrics)

+ func (eb *Unit) AddEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (eb *Unit) ComboPoints() int32

+ func (eb *Unit) CurrentEnergy() float64

+ func (eb *Unit) NextEnergyTickAt() time.Duration

+ func (eb *Unit) ResetEnergyTick(sim *Simulation)

+ func (eb *Unit) SpendComboPoints(sim *Simulation, metrics *ResourceMetrics)

+ func (eb *Unit) SpendEnergy(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Unit) AddFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (fb *Unit) CurrentFocus() float64

+ func (fb *Unit) CurrentFocusPerTick() float64

+ func (fb *Unit) SpendFocus(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Unit) CurrentHealth() float64

+ func (hb *Unit) CurrentHealthPercent() float64

+ func (hb *Unit) GainHealth(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (hb *Unit) MaxHealth() float64

+ func (hb *Unit) RemoveHealth(sim *Simulation, amount float64)

+ func (mb *Unit) EndOOMEvent(sim *Simulation)

+ func (mb *Unit) IsOOM() bool

+ func (mb *Unit) StartOOMEvent(sim *Simulation, requiredMana float64)

+ func (rb *Unit) AddRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (rb *Unit) CurrentRage() float64

+ func (rb *Unit) SpendRage(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (unit *Unit) AddBonusRangedCritRating(amount float64)

+ func (unit *Unit) AddBonusRangedHitRating(amount float64)

+ func (unit *Unit) AddDynamicDamageTakenModifier(ddtm DynamicDamageTakenModifier)

+ func (unit *Unit) AddMana(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (unit *Unit) AddStat(stat stats.Stat, amount float64)

+ func (unit *Unit) AddStatDynamic(sim *Simulation, stat stats.Stat, amount float64)

+ func (unit *Unit) AddStats(stat stats.Stats)

+ func (unit *Unit) AddStatsDynamic(sim *Simulation, bonus stats.Stats)

+ func (unit *Unit) ApplyCastSpeed(dur time.Duration) time.Duration

+ func (unit *Unit) ApplyCastSpeedForSpell(dur time.Duration, spell *Spell) time.Duration

+ func (unit *Unit) Armor() float64

+ func (unit *Unit) ArmorPenetrationPercentage(armorPenRating float64) float64

+ func (unit *Unit) BlockValue() float64

+ func (unit *Unit) CancelGCDTimer(sim *Simulation)

+ func (unit *Unit) CurrentMana() float64

+ func (unit *Unit) CurrentManaPercent() float64

+ func (unit *Unit) DisableDynamicStatDep(sim *Simulation, dep *stats.StatDependency)

+ func (unit *Unit) EnableAutoAttacks(agent Agent, options AutoAttackOptions)

+ func (unit *Unit) EnableDynamicStatDep(sim *Simulation, dep *stats.StatDependency)

+ func (unit *Unit) EnableEnergyBar(maxEnergy float64)

+ func (unit *Unit) EnableFocusBar(regenMultiplier float64, onFocusGain OnFocusGain)

+ func (unit *Unit) EnableHealthBar()

+ func (unit *Unit) EnableRageBar(options RageBarOptions)

+ func (unit *Unit) ExecuteCustomRotation(sim *Simulation)

+ func (unit *Unit) GetCritTakenMultiplier(spell *Spell) float64

+ func (unit *Unit) GetCurrentPowerBar() PowerBarType

+ func (unit *Unit) GetDiminishedDodgeChance() float64

+ func (unit *Unit) GetDiminishedMissChance() float64

+ func (unit *Unit) GetDiminishedParryChance() float64

+ func (unit *Unit) GetInitialStat(stat stats.Stat) float64

+ func (unit *Unit) GetManaNotCastingMetrics() *ResourceMetrics

+ func (unit *Unit) GetMetadata() *proto.UnitMetadata

+ func (unit *Unit) GetOpponents() []*Unit

+ func (unit *Unit) GetOrInitTimer(timer **Timer) *Timer

+ func (unit *Unit) GetOrRegisterAura(aura Aura) *Aura

+ func (unit *Unit) GetOrRegisterSpell(config SpellConfig) *Spell

+ func (unit *Unit) GetSchoolDamageDoneMultiplier(spell *Spell) float64

+ func (unit *Unit) GetSchoolDamageTakenMultiplier(spell *Spell) float64

+ func (unit *Unit) GetSpell(actionID ActionID) *Spell

+ func (unit *Unit) GetSpellsMatchingSchool(school SpellSchool) []*Spell

+ func (unit *Unit) GetStat(stat stats.Stat) float64

+ func (unit *Unit) GetStats() stats.Stats

+ func (unit *Unit) GetUnit(ref *proto.UnitReference) *Unit

+ func (unit *Unit) HasEnergyBar() bool

+ func (unit *Unit) HasFocusBar() bool

+ func (unit *Unit) HasHealthBar() bool

+ func (unit *Unit) HasManaBar() bool

+ func (unit *Unit) HasRageBar() bool

+ func (unit *Unit) HasTemporaryBonusForStat(stat stats.Stat) bool

+ func (unit *Unit) HasTemporaryMeleeSwingSpeedIncrease() bool

+ func (unit *Unit) HasTemporaryRangedSwingSpeedIncrease() bool

+ func (unit *Unit) HasTemporarySpellCastSpeedIncrease() bool

+ func (unit *Unit) InitialCastSpeed() float64

+ func (unit *Unit) IsActive() bool

+ func (unit *Unit) IsEnabled() bool

+ func (unit *Unit) IsOpponent(other *Unit) bool

+ func (unit *Unit) Log(sim *Simulation, message string, vals ...interface{})

+ func (unit *Unit) LogLabel() string

+ func (unit *Unit) MHNormalizedWeaponDamage(sim *Simulation, attackPower float64) float64

+ func (unit *Unit) MHWeaponDamage(sim *Simulation, attackPower float64) float64

+ func (unit *Unit) MP5ManaRegenPerSecond() float64

+ func (unit *Unit) ManaRegenPerSecondWhileCasting() float64

+ func (unit *Unit) ManaRegenPerSecondWhileNotCasting() float64

+ func (unit *Unit) ManaTick(sim *Simulation)

+ func (unit *Unit) MaxMana() float64

+ func (unit *Unit) MoveTo(moveRange float64, sim *Simulation)

+ func (unit *Unit) MultiplyAttackSpeed(sim *Simulation, amount float64)

+ func (unit *Unit) MultiplyCastSpeed(amount float64)

+ func (unit *Unit) MultiplyMeleeSpeed(sim *Simulation, amount float64)

+ func (unit *Unit) MultiplyRangedSpeed(sim *Simulation, amount float64)

+ func (unit *Unit) NewAPLAction(rot *APLRotation, config *proto.APLAction) APLActionImpl

+ func (unit *Unit) NewAPLValue(rot *APLRotation, config *proto.APLValue) APLValue

+ func (unit *Unit) NewComboPointMetrics(actionID ActionID) *ResourceMetrics

+ func (unit *Unit) NewEnergyMetrics(actionID ActionID) *ResourceMetrics

+ func (unit *Unit) NewFocusMetrics(actionID ActionID) *ResourceMetrics

+ func (unit *Unit) NewHealthMetrics(actionID ActionID) *ResourceMetrics

+ func (unit *Unit) NewManaMetrics(actionID ActionID) *ResourceMetrics

+ func (unit *Unit) NewRageMetrics(actionID ActionID) *ResourceMetrics

+ func (unit *Unit) NewTimer() *Timer

+ func (unit *Unit) NextGCDAt() time.Duration

+ func (unit *Unit) OHNormalizedWeaponDamage(sim *Simulation, attackPower float64) float64

+ func (unit *Unit) OHWeaponDamage(sim *Simulation, attackPower float64) float64

+ func (unit *Unit) OnSpellRegistered(handler SpellRegisteredHandler)

+ func (unit *Unit) RangedSwingSpeed() float64

+ func (unit *Unit) RangedWeaponDamage(sim *Simulation, attackPower float64) float64

+ func (unit *Unit) RegisterAura(aura Aura) *Aura

+ func (unit *Unit) RegisterPrepullAction(doAt time.Duration, action func(*Simulation))

+ func (unit *Unit) RegisterSpell(config SpellConfig) *Spell

+ func (unit *Unit) SetCurrentPowerBar(bar PowerBarType)

+ func (unit *Unit) SetGCDTimer(sim *Simulation, gcdReadyAt time.Duration)

+ func (unit *Unit) SpellGCD() time.Duration

+ func (unit *Unit) SpendMana(sim *Simulation, amount float64, metrics *ResourceMetrics)

+ func (unit *Unit) SpiritManaRegenPerSecondDefault() float64

+ func (unit *Unit) SwingSpeed() float64

+ func (unit *Unit) TimeUntilManaRegen(desiredMana float64) time.Duration

+ func (unit *Unit) UpdateManaRegenRates()

+ func (unit *Unit) WaitUntil(sim *Simulation, readyTime time.Duration)

+ type UnitMetrics struct

+ func NewUnitMetrics() UnitMetrics

+ func (unitMetrics *UnitMetrics) AddFinalPetMetrics(petMetrics *UnitMetrics)

+ func (unitMetrics *UnitMetrics) AddOOMTime(sim *Simulation, dur time.Duration)

+ func (unitMetrics *UnitMetrics) MarkOOM(sim *Simulation)

+ func (unitMetrics *UnitMetrics) NewResourceMetrics(actionID ActionID, resourceType proto.ResourceType) *ResourceMetrics

+ func (unitMetrics *UnitMetrics) ToProto() *proto.UnitMetrics

+ func (unitMetrics *UnitMetrics) UpdateDpasp(dpspSeconds float64)

+ type UnitReference struct

+ func NewUnitReference(ref *proto.UnitReference, contextUnit *Unit) UnitReference

+ func (ur *UnitReference) String() string

+ func (ur UnitReference) Get() *Unit

+ type UnitStats struct

+ PseudoStats []float64

+ Stats stats.Stats

+ func NewUnitStats() UnitStats

+ func (s *UnitStats) AddStat(stat stats.UnitStat, value float64)

+ func (s *UnitStats) Get(stat stats.UnitStat) float64

+ func (s *UnitStats) ToProto() *proto.UnitStats

+ type UnitType int

+ const EnemyUnit

+ const PetUnit

+ const PlayerUnit

+ type Weapon struct

+ AttackPowerPerDPS float64

+ BaseDamageMax float64

+ BaseDamageMin float64

+ CritMultiplier float64

+ NormalizedSwingSpeed float64

+ SpellSchool SpellSchool

+ SwingSpeed float64

+ func (weapon *Weapon) AverageDamage() float64

+ func (weapon *Weapon) BaseDamage(sim *Simulation) float64

+ func (weapon *Weapon) CalculateAverageWeaponDamage(attackPower float64) float64

+ func (weapon *Weapon) CalculateNormalizedWeaponDamage(sim *Simulation, attackPower float64) float64

+ func (weapon *Weapon) CalculateWeaponDamage(sim *Simulation, attackPower float64) float64

+ func (weapon *Weapon) DPS() float64

+ func (weapon *Weapon) EnemyWeaponDamage(sim *Simulation, attackPower float64, damageSpread float64) float64

+ func (weapon *Weapon) GetSpellSchool() SpellSchool

+ type WeaponAttack struct

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL