stats

package
v1.5.1 Latest Latest
Warning

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

 Go to latest Published: Dec 18, 2022 License: MIT Imports: 3 Imported by: 28

Documentation

Index

Constants

View Source 
const (
	OnField  FieldStatus = "on_field"
	OffField FieldStatus = "off_field"

	Amp15     ReactionModifier = "amp_1_5"
	Amp20     ReactionModifier = "amp_2_0"
	Spread    ReactionModifier = "spread"
	Aggravate ReactionModifier = "aggravate"
)

Variables

This section is empty.

Functions

func Register 

func Register(f NewStatsFunc)

Types

type ActionEvent 

type ActionEvent struct {
	Frame    int    `msg:"frame"`
	ActionId int    `msg:"action_id"`
	Action   string `msg:"action"`
}

func (*ActionEvent) DecodeMsg 

func (z *ActionEvent) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (ActionEvent) EncodeMsg 

func (z ActionEvent) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (ActionEvent) MarshalMsg 

func (z ActionEvent) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (ActionEvent) Msgsize 

func (z ActionEvent) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ActionEvent) UnmarshalMsg 

func (z *ActionEvent) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ActionFailInterval 

type ActionFailInterval struct {
	Start  int    `msg:"start"`
	End    int    `msg:"end"`
	Reason string `msg:"reason"`
}

func (*ActionFailInterval) DecodeMsg 

func (z *ActionFailInterval) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (ActionFailInterval) EncodeMsg 

func (z ActionFailInterval) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (ActionFailInterval) MarshalMsg 

func (z ActionFailInterval) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (ActionFailInterval) Msgsize 

func (z ActionFailInterval) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ActionFailInterval) UnmarshalMsg 

func (z *ActionFailInterval) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ActiveCharacterInterval 

type ActiveCharacterInterval struct {
	Start     int `msg:"start"`
	End       int `msg:"end"`
	Character int `msg:"character"`
}

func (*ActiveCharacterInterval) DecodeMsg 

func (z *ActiveCharacterInterval) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (ActiveCharacterInterval) EncodeMsg 

func (z ActiveCharacterInterval) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (ActiveCharacterInterval) MarshalMsg 

func (z ActiveCharacterInterval) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (ActiveCharacterInterval) Msgsize 

func (z ActiveCharacterInterval) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ActiveCharacterInterval) UnmarshalMsg 

func (z *ActiveCharacterInterval) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type CharacterResult 

type CharacterResult struct {
	// For raw data usage outside of gcsim only
	Name string `msg:"name"`

	DamageEvents   []DamageEvent   `msg:"damage_events"`
	ReactionEvents []ReactionEvent `msg:"reaction_events"`
	ActionEvents   []ActionEvent   `msg:"action_events"`
	EnergyEvents   []EnergyEvent   `msg:"energy_events"`
	HealEvents     []HealEvent     `msg:"heal_events"`

	// TODO: Move to Result since only active character can perform actions?
	FailedActions []ActionFailInterval `msg:"failed_actions"`

	EnergyStatus []float64 `msg:"energy"` // can be completely replaced by EnergyEvents?
	HealthStatus []float64 `msg:"health"`

	ActiveTime  int     `msg:"active_time"`
	EnergySpent float64 `msg:"energy_spent"`
}

func (*CharacterResult) DecodeMsg 

func (z *CharacterResult) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*CharacterResult) EncodeMsg 

func (z *CharacterResult) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*CharacterResult) MarshalMsg 

func (z *CharacterResult) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*CharacterResult) Msgsize 

func (z *CharacterResult) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*CharacterResult) UnmarshalMsg 

func (z *CharacterResult) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type DamageEvent 

type DamageEvent struct {
	Frame            int              `msg:"frame"`
	ActionId         int              `msg:"action_id"`
	Source           string           `msg:"src"`
	Target           int              `msg:"target"`
	Element          string           `msg:"element"`
	ReactionModifier ReactionModifier `msg:"reaction_modifier"`
	Crit             bool             `msg:"crit"`
	Modifiers        []string         `msg:"modifiers"`
	Mitigation       float64          `msg:"mitigation_modifier"`
	Damage           float64          `msg:"damage"`
}

func (*DamageEvent) DecodeMsg 

func (z *DamageEvent) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*DamageEvent) EncodeMsg 

func (z *DamageEvent) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*DamageEvent) MarshalMsg 

func (z *DamageEvent) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*DamageEvent) Msgsize 

func (z *DamageEvent) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*DamageEvent) UnmarshalMsg 

func (z *DamageEvent) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type EnemyResult 

type EnemyResult struct {
	ReactionStatus []ReactionStatusInterval `msg:"reaction_status"`
	ReactionUptime map[string]int           `msg:"reaction_uptime"` // can calculate from intervals?
}

func (*EnemyResult) DecodeMsg 

func (z *EnemyResult) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*EnemyResult) EncodeMsg 

func (z *EnemyResult) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*EnemyResult) MarshalMsg 

func (z *EnemyResult) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*EnemyResult) Msgsize 

func (z *EnemyResult) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*EnemyResult) UnmarshalMsg 

func (z *EnemyResult) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type EnergyEvent 

type EnergyEvent struct {
	Frame   int         `msg:"frame"`
	Source  string      `msg:"src"`
	Status  FieldStatus `msg:"field_status"`
	Gained  float64     `msg:"gained"`
	Wasted  float64     `msg:"wasted"`
	Current float64     `msg:"current"` // this is pre + gained
}

func (*EnergyEvent) DecodeMsg 

func (z *EnergyEvent) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*EnergyEvent) EncodeMsg 

func (z *EnergyEvent) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*EnergyEvent) MarshalMsg 

func (z *EnergyEvent) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*EnergyEvent) Msgsize 

func (z *EnergyEvent) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*EnergyEvent) UnmarshalMsg 

func (z *EnergyEvent) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type FieldStatus 

type FieldStatus string

func (*FieldStatus) DecodeMsg 

func (z *FieldStatus) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (FieldStatus) EncodeMsg 

func (z FieldStatus) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (FieldStatus) MarshalMsg 

func (z FieldStatus) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (FieldStatus) Msgsize 

func (z FieldStatus) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*FieldStatus) UnmarshalMsg 

func (z *FieldStatus) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type HealEvent 

type HealEvent struct {
	Frame  int     `msg:"frame"`
	Source string  `msg:"src"`
	Target int     `msg:"target"`
	Heal   float64 `msg:"heal"`
}

Heal events are stored in the source character

func (*HealEvent) DecodeMsg 

func (z *HealEvent) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*HealEvent) EncodeMsg 

func (z *HealEvent) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*HealEvent) MarshalMsg 

func (z *HealEvent) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*HealEvent) Msgsize 

func (z *HealEvent) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*HealEvent) UnmarshalMsg 

func (z *HealEvent) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type LegacyResult 

type LegacyResult struct {
	DamageOverTime        map[string]float64   `msg:"damage_over_time"`
	DamageByChar          []map[string]float64 `msg:"damage_by_char"`
	DamageByCharByTargets []map[string]float64 `msg:"damage_by_char_by_targets"`
	DamageInstancesByChar []map[string]int     `msg:"damage_instances_by_char"`
	AbilUsageCountByChar  []map[string]int     `msg:"abil_usage_count_by_char"`
	CharActiveTime        []int                `msg:"char_active_time"`
	ElementUptime         []map[string]int     `msg:"element_uptime"`
	ParticleCount         map[string]float64   `msg:"particle_count"`
	ReactionsTriggered    map[string]int       `msg:"reactions_triggered"`
}

func (*LegacyResult) DecodeMsg 

func (z *LegacyResult) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*LegacyResult) EncodeMsg 

func (z *LegacyResult) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*LegacyResult) MarshalMsg 

func (z *LegacyResult) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*LegacyResult) Msgsize 

func (z *LegacyResult) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*LegacyResult) UnmarshalMsg 

func (z *LegacyResult) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type NewStatsFunc 

type NewStatsFunc func(core *core.Core) (StatsCollector, error)

func Collectors 

func Collectors() []NewStatsFunc

type ReactionEvent 

type ReactionEvent struct {
	Frame    int    `msg:"frame"`
	Source   string `msg:"src"`
	Target   int    `msg:"target"`
	Reaction string `msg:"reaction"`
}

func (*ReactionEvent) DecodeMsg 

func (z *ReactionEvent) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*ReactionEvent) EncodeMsg 

func (z *ReactionEvent) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*ReactionEvent) MarshalMsg 

func (z *ReactionEvent) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*ReactionEvent) Msgsize 

func (z *ReactionEvent) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ReactionEvent) UnmarshalMsg 

func (z *ReactionEvent) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ReactionModifier 

type ReactionModifier string

func (*ReactionModifier) DecodeMsg 

func (z *ReactionModifier) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (ReactionModifier) EncodeMsg 

func (z ReactionModifier) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (ReactionModifier) MarshalMsg 

func (z ReactionModifier) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (ReactionModifier) Msgsize 

func (z ReactionModifier) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ReactionModifier) UnmarshalMsg 

func (z *ReactionModifier) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ReactionStatusInterval 

type ReactionStatusInterval struct {
	Start int    `msg:"start"`
	End   int    `msg:"end"`
	Type  string `msg:"type"`
}

func (*ReactionStatusInterval) DecodeMsg 

func (z *ReactionStatusInterval) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (ReactionStatusInterval) EncodeMsg 

func (z ReactionStatusInterval) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (ReactionStatusInterval) MarshalMsg 

func (z ReactionStatusInterval) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (ReactionStatusInterval) Msgsize 

func (z ReactionStatusInterval) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ReactionStatusInterval) UnmarshalMsg 

func (z *ReactionStatusInterval) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Result 

type Result struct {
	Seed        uint64  `msg:"seed"`
	Duration    int     `msg:"duration"`
	TotalDamage float64 `msg:"total_damage"`
	DPS         float64 `msg:"dps"`

	// TODO: Remove. just here for backwards compatibility
	Legacy LegacyResult `msg:"legacy"`

	ActiveCharacters []ActiveCharacterInterval `msg:"active_characters"`
	Shields          []ShieldInterval          `msg:"shields"`
	DamageMitigation []float64                 `msg:"damage_mitigation"`

	Characters []CharacterResult `msg:"characters"`
	Enemies    []EnemyResult     `msg:"enemies"`
}

func (*Result) DecodeMsg 

func (z *Result) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Result) EncodeMsg 

func (z *Result) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Result) MarshalMsg 

func (z *Result) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Result) Msgsize 

func (z *Result) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Result) UnmarshalMsg 

func (z *Result) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ShieldInterval 

type ShieldInterval struct {
	Start      int     `msg:"start"`
	End        int     `msg:"end"`
	Name       string  `msg:"name"`
	Absorption float64 `msg:"absoption"`
}

func (*ShieldInterval) DecodeMsg 

func (z *ShieldInterval) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*ShieldInterval) EncodeMsg 

func (z *ShieldInterval) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*ShieldInterval) MarshalMsg 

func (z *ShieldInterval) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*ShieldInterval) Msgsize 

func (z *ShieldInterval) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ShieldInterval) UnmarshalMsg 

func (z *ShieldInterval) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type StatsCollector 

type StatsCollector interface {
	Flush(core *core.Core, result *Result)
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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