combat

type AbilUsage struct {
	Actor  string `json:"actor"`
	Action string `json:"action"`
	Param  string `json:"param"`
}

type Action struct {
	Name   string
	Target string //either character or a sequence name

	Exec     []ActionItem //if len > 1 then it's a sequence
	IsSeq    bool         // is this a sequence
	IsStrict bool         //strict sequence?
	Once     bool         // is this an opener (execute once)
	Disabled bool         // is this action disabled
	Pos      int          //current position in execution, default 0

	Last       int //last time this was executed (frame)
	ActionLock int //how many frames this action is locked from executing again

	ActiveCond string
	SwapTo     string
	SwapLock   int
	PostAction ActionType

	Conditions *ExprTreeNode //conditions to be met

	Raw []string //raw action in string
}

type ActionItem struct {
	Typ    ActionType
	Param  map[string]int
	Target string
	// contains filtered or unexported fields
}

type ActionType int

type AttackTag int //attacktag is used instead of actions etc..

type Aura interface {
	React(ds Snapshot, s *Sim) Aura
	Tick(s *Sim) bool //remove if true
	Attach(e EleType, durability float64, f int)
	Refresh(dur float64, s *Sim)
	E() EleType
	ContainsEle(e EleType) bool
}

type CDAdjust struct {
	Key    string
	Amount func(a ActionType) float64
	Expiry int
}

type CharStatMod struct {
	Key       string
	Mod       []float64
	Condition func(ds Snapshot) bool
	Expiry    int
}

type CharTask struct {
	Name  string
	F     func()
	Delay int
	// contains filtered or unexported fields
}

type Character interface {
	Init(index int) //to be called when everything including weapon and artifacts has been loaded
	Tick()          //function to be called every frame

	//information functions
	Name() string
	CharIndex() int
	Ele() EleType
	WeaponClass() WeaponClass
	CurrentEnergy() float64 //current energy
	TalentLvlSkill() int
	TalentLvlAttack() int
	TalentLvlBurst() int
	HP() float64
	MaxHP() float64
	ModifyHP(float64)

	//actions
	Attack(p map[string]int) int
	Aimed(p map[string]int) int
	ChargeAttack(p map[string]int) int
	HighPlungeAttack(p map[string]int) int
	LowPlungeAttack(p map[string]int) int
	Skill(p map[string]int) int
	Burst(p map[string]int) int
	Dash(p map[string]int) int

	//info methods
	ActionReady(a ActionType, p map[string]int) bool
	ActionFrames(a ActionType, p map[string]int) int
	ActionStam(a ActionType, p map[string]int) float64

	//char stat mods
	AddMod(mod CharStatMod)
	AddWeaponInfuse(inf WeaponInfusion)

	//cooldown stuff
	SetCD(a ActionType, dur int)
	Cooldown(a ActionType) int
	ResetActionCooldown(a ActionType)
	ReduceActionCooldown(a ActionType, v int)
	AddCDAdjustFunc(rd CDAdjust)

	//status stuff
	Tag(key string) int

	//energy
	ReceiveParticle(p Particle, isActive bool, partyCount int)
	AddEnergy(e float64)

	//combat
	Snapshot(name string, a AttackTag, icd ICDTag, g ICDGroup, st StrikeType, e EleType, d float64, mult float64) Snapshot
	ResetNormalCounter()
}

type CharacterBase struct {
	Name    string  `yaml:"Name"`
	Element EleType `yaml:"Element"`
	Level   int     `yaml:"Level"`
	HP      float64 `yaml:"BaseHP"`
	Atk     float64 `yaml:"BaseAtk"`
	Def     float64 `yaml:"BaseDef"`
	Cons    int     `yaml:"Constellation"`
	StartHP float64
}

type CharacterProfile struct {
	Base    CharacterBase `yaml:"Base"`
	Weapon  WeaponProfile `yaml:"Weapon"`
	Talents TalentProfile
	Stats   []float64
	Sets    map[string]int
}

type CharacterTemplate struct {
	S     *Sim
	Index int
	//this should describe the frame in which the abil becomes available
	//if frame > current then it's available. no need to decrement this way
	// CD        map[string]int
	ActionCD []int
	Mods     []CharStatMod
	Tags     map[string]int
	//Profile info
	Base     CharacterBase
	Weapon   WeaponProfile
	Stats    []float64
	Talents  TalentProfile
	SkillCon int
	BurstCon int

	CDReductionFuncs []CDAdjust

	Energy    float64
	MaxEnergy float64

	HPCurrent float64
	HPMax     float64

	//Tasks specific to the character to be executed at set frames
	Tasks map[int][]CharTask
	//counters
	NormalHitNum  int //how many hits in a normal combo
	NormalCounter int

	//infusion
	Infusion WeaponInfusion //TODO currently just overides the old; disregarding any existing
}

type Condition struct {
	Fields []string
	Op     string
	Value  int
}

type ConfigArtifact struct {
	Level int                `yaml:"Level"`
	Set   string             `yaml:"Set"`
	Main  map[string]float64 `yaml:"Main"`
	Sub   map[string]float64 `yaml:"Sub"`
}

type Construct interface {
	OnDestruct()
	Key() int
	Type() GeoConstructType
	Expiry() int
	IsLimited() bool
	Count() int
}

type CryoAura struct {
	*Element
}

type DefMod struct {
	Key    int
	Value  float64
	Expiry int
}

type EffectFunc func(s *Sim) bool

type EleType int

type ElectroAura struct {
	*Element
}

type ElectroChargeAura struct {
	*Element
	Hydro    *HydroAura
	Electro  *ElectroAura
	NextTick int
	Snap     Snapshot
}

type Element struct {
	Type          EleType
	MaxDurability float64
	Durability    float64
	Start         int //when the aura was first added
	Expiry        int //when the aura is gone, use this instead of ticks
}

type Enemy struct {
	Level int

	HPMode bool
	MaxHP  float64
	HP     float64

	F   *int
	Log *zap.SugaredLogger

	//stats
	Damage float64 //total damage received
	// contains filtered or unexported fields
}

type EnemyProfile struct {
	Level  int                 `yaml:"Level"`
	Resist map[EleType]float64 `yaml:"Resist"`
}

type ExprTreeNode struct {
	Left   *ExprTreeNode
	Right  *ExprTreeNode
	IsLeaf bool
	Op     string //&& || ( )
	Expr   Condition
}

type Flags struct {
	ChildeActive        bool
	AmpReactionDidOccur bool
	AmpReactionType     ReactionType
	NextAttackMVMult    float64 // melt vape multiplier
	// ReactionDamageTriggered bool
	Custom map[string]int
}

type FreezeAura struct {
	*Element
	OldHydro *HydroAura
	OldCryo  *CryoAura
	NewHydro *HydroAura
	NewCryo  *CryoAura
	Expire   int
}

type GeoConstructType int

type HurtEvent struct {
	WillHurt bool
	Once     bool //how often
	Start    int  //
	End      int
	Min      float64
	Max      float64
	Ele      EleType
}

type HydroAura struct {
	*Element
}

type ICDGroup int //same ICD group shares the same timer

type ICDTag int //same ICD tag shares the same counter

type LogConfig struct {
	LogLevel      string
	LogFile       string
	LogShowCaller bool
	LogEvents     []bool
}

type LogSource int

type NewCharacterFunc func(s *Sim, p CharacterProfile) (Character, error)

type NewSetFunc func(c Character, s *Sim, count int)

type NewWeaponFunc func(c Character, s *Sim, refine int, params map[string]int)

type NoAura struct {
	*Element
}

type Particle struct {
	Source string
	Num    int
	Ele    EleType
	Delay  int
}

type Profile struct {
	Label         string             `yaml:"Label"`
	Enemy         EnemyProfile       `yaml:"Enemy"`
	InitialActive string             `yaml:"InitialActive"`
	Characters    []CharacterProfile `yaml:"Characters"`
	Rotation      []Action
	Hurt          HurtEvent
	LogConfig     LogConfig
	LogStats      bool
	FixedRand     bool //if this is true then use the same seed
}

type PyroAura struct {
	*Element
}

type ReactionType string

type ResistMod struct {
	Key      string
	Ele      EleType
	Value    float64
	Duration int
	Expiry   int
}

type Shield interface {
	Key() int
	Type() ShieldType
	OnDamage(dmg float64, ele EleType, bonus float64) (float64, bool) //return dmg taken and shield stays
	OnExpire()
	OnOverwrite()
	Expiry() int
	CurrentHP() float64
	Element() EleType
	Desc() string
}

type ShieldType int

type Sim struct {
	Target           *Enemy
	Status           map[string]int
	ActiveChar       string
	ActiveIndex      int
	CharActiveLength int
	Chars            []Character
	SwapCD           int
	Stats            SimStats

	//log related
	Log         *zap.SugaredLogger
	DebugDetail bool

	//icd related
	ICDGroupOnTimer       [][]bool
	ICDTagCounter         [][]int
	ICDDamageGroupOnTimer [][]bool
	ICDDamageGroupCounter [][]int

	//stam related
	LastStamUse  int
	Stam         float64
	StamModifier []func(a ActionType) float64

	DRFunc           []func() float64
	ShieldBonusFunc  []func() float64
	IncHealBonusFunc []func() float64 //% to add to amount healed

	//hurt event
	LastHurt int
	Hurt     HurtEvent
	OnHurt   []func(s *Sim)

	//reaction related
	TargetAura Aura

	Rand *rand.Rand

	F int

	GlobalFlags Flags
	// contains filtered or unexported fields
}

type SimStats struct {
	AuraUptime map[EleType]int `json:"aura_uptime"` //uptime in frames

	//these follow 4 are available in avg mode as well
	CharNames            []string             `json:"char_names"`
	DamageByChar         []map[string]float64 `json:"damage_by_char"`
	CharActiveTime       []int                `json:"char_active_time"`
	AbilUsageCountByChar []map[string]int     `json:"abil_usage_count_by_char"`
	ReactionsTriggered   map[ReactionType]int `json:"reactions_triggered"`
	SimDuration          int                  `json:"sim_duration"`
	//super detailed data by frame, only in time mode
	Detailed struct {
		DamageHist         []float64         `json:"damage_hist"`
		LogDetailed        bool              `json:"-"`
		CharActiveFrame    [][]int           `json:"char_active_frame"`
		ElementActiveFrame map[EleType][]int `json:"element_active_frame"`
		AbilUsageByFrame   []AbilUsage       `json:"abil_usage_frame"`
	} `json:"detailed"`

	//final result
	DPS float64 `json:"dps"`
}

type Snapshot struct {
	CharLvl    int
	ActorEle   EleType
	Actor      string //name of the character triggering the damage
	ActorIndex int

	SourceFrame     int
	AnimationFrames int //really only for amos bow...

	Abil        string      //name of ability triggering the damage
	WeaponClass WeaponClass //b.c. Gladiators...
	AttackTag   AttackTag
	ICDTag      ICDTag
	ICDGroup    ICDGroup
	ImpulseLvl  int

	HitWeakPoint bool
	Mult         float64 //ability multiplier. could set to 0 from initial Mona dmg
	StrikeType   StrikeType
	Element      EleType //element of ability
	Durability   float64 //durability of aura, 0 if nothing applied

	UseDef  bool    //default false
	FlatDmg float64 //flat dmg; so far only zhongli

	Stats []float64 //total character stats including from artifact, bonuses, etc...

	BaseAtk float64 //base attack used in calc
	BaseDef float64 //base def used in calc

	//reaction flags
	IsReaction   bool
	ReactionType ReactionType
	IsMeltVape   bool    //trigger melt/vape
	ReactMult    float64 //reaction multiplier for melt/vape
	ReactBonus   float64 //reaction bonus %+ such as witch; should be 0 and only affected by hooks

}

type StatType int

type StrikeType int

type TalentProfile struct {
	Attack int
	Skill  int
	Burst  int
}

type Task struct {
	Name  string
	F     TaskFunc
	Delay int
	// contains filtered or unexported fields
}

type TaskFunc func(s *Sim)

type TemplateShield struct {
	Name       string
	Src        int
	ShieldType ShieldType
	Ele        EleType
	HP         float64
	Expires    int
}

type WeaponClass string

type WeaponInfusion struct {
	Key    string
	Ele    EleType
	Tags   []AttackTag
	Expiry int
}

type WeaponProfile struct {
	Name   string      `yaml:"WeaponName"`
	Class  WeaponClass `yaml:"WeaponClass"`
	Refine int         `yaml:"WeaponRefinement"`
	Atk    float64     `yaml:"WeaponBaseAtk"`
	Param  map[string]int
}