Inheritance diagram for attack_t:

Public Member Functions
	attack_t (util::string_view token, player_t *p)

	attack_t (util::string_view token, player_t p, const spell_data_t s)

timespan_t	execute_time () const override

void	execute () override

result_e	calculate_result (action_state_t *) const override

void	init () override

result_amount_type	amount_type (const action_state_t *, bool=false) const override

result_amount_type	report_amount_type (const action_state_t *) const override

double	miss_chance (double hit, player_t *t) const override

double	dodge_chance (double, player_t *t) const override

double	block_chance (action_state_t *s) const override

double	crit_block_chance (action_state_t *s) const override

double	bonus_da (const action_state_t *) const override

double	action_multiplier () const override

double	composite_target_multiplier (player_t *target) const override

double	composite_hit () const override

double	composite_crit_chance () const override

double	composite_crit_chance_multiplier () const override

double	composite_haste () const override

double	composite_versatility (const action_state_t *state) const override

double	recharge_multiplier (const cooldown_t &cd) const override

virtual double	composite_expertise () const

virtual void	reschedule_auto_attack (double old_swing_haste)

void	reset () override

Public Member Functions inherited from action_t
	action_t (action_e type, util::string_view token, player_t *p)

	action_t (action_e type, util::string_view token, player_t p, const spell_data_t s)

void	add_child (action_t *child)

void	add_option (std::unique_ptr< option_t > new_option)

void	check_spec (specialization_e)

void	check_spell (const spell_data_t *)

const spell_data_t &	data () const
	Spell Data associated with the action. More...

const spell_data_t &	data_reporting () const

dot_t *	find_dot (player_t *target) const

bool	is_aoe () const

const char *	name () const

const char *	name_reporting () const

size_t	num_travel_events () const

bool	has_travel_events () const

timespan_t	shortest_travel_event () const
	Determine the remaining duration of the next travel event.

bool	has_travel_events_for (const player_t *target) const
	Determine if a travel event for given target currently exists.

virtual bool	has_amount_result () const
	Determine if the action can have a resulting damage/heal amount > 0.

void	parse_spell_data (const spell_data_t &)
	Parse spell data values and write them into corresponding action_t members.

void	parse_effect_direct_mods (const spelleffect_data_t &spelleffect_data, bool item_scaling)

void	parse_effect_periodic_mods (const spelleffect_data_t &spelleffect_data, bool item_scaling)

void	parse_effect_period (const spelleffect_data_t &)

void	parse_effect_data (const spelleffect_data_t &)

void	parse_target_str ()

void	remove_travel_event (travel_event_t *e)

void	reschedule_queue_event ()

rng::rng_t &	rng ()

rng::rng_t &	rng () const

player_t *	select_target_if_target ()

void	apply_affecting_aura (const spell_data_t *)

void	apply_affecting_effect (const spelleffect_data_t &effect)

void	apply_affecting_conduit (const conduit_data_t &conduit, int effect_num=1)

void	apply_affecting_conduit_effect (const conduit_data_t &conduit, size_t effect_num)

action_state_t *	get_state (const action_state_t *=nullptr)

void	execute_on_target (player_t *, double=-1.0)

virtual bool	verify_actor_level () const

virtual bool	verify_actor_spec () const

virtual bool	verify_actor_weapon () const

virtual double	cost () const
	Resource cost of the action for current_resource()

virtual double	base_cost () const

virtual double	cost_per_tick (resource_e) const

virtual timespan_t	cooldown_duration () const

virtual timespan_t	gcd () const

virtual double	false_positive_pct () const
	False Positive skill chance, executes command regardless of expression. More...

virtual double	false_negative_pct () const

virtual timespan_t	tick_time (const action_state_t *state) const

virtual timespan_t	travel_time () const

virtual timespan_t	distance_targeting_travel_time (action_state_t *s) const

virtual block_result_e	calculate_block_result (action_state_t *s) const

virtual double	calculate_direct_amount (action_state_t *state) const

virtual double	calculate_tick_amount (action_state_t *state, double multiplier) const

virtual double	calculate_weapon_damage (double attack_power) const

virtual double	calculate_crit_damage_bonus (action_state_t *s) const

virtual double	recharge_rate_multiplier (const cooldown_t &) const

virtual timespan_t	cooldown_base_duration (const cooldown_t &cd) const
	Cooldown base duration for action based cooldowns. More...

virtual resource_e	current_resource () const

virtual int	n_targets () const

virtual double	last_tick_factor (const dot_t *d, timespan_t time_to_tick, timespan_t duration) const

virtual school_e	get_school () const
	Use when damage schools change during runtime.

virtual double	parry_chance (double, player_t *) const

virtual double	glance_chance (int) const

virtual double	total_crit_bonus (const action_state_t *) const

virtual int	num_targets () const

virtual size_t	available_targets (std::vector< player_t * > &) const

virtual std::vector< player_t *> &	target_list () const

virtual player_t *	find_target_by_number (int number) const

virtual bool	execute_targeting (action_t *action) const

virtual std::vector< player_t * > &	targets_in_range_list (std::vector< player_t * > &tl) const

virtual std::vector< player_t * > &	check_distance_targeting (std::vector< player_t * > &tl) const

virtual double	ppm_proc_chance (double PPM) const

virtual bool	usable_moving () const

virtual timespan_t	composite_dot_duration (const action_state_t *) const

virtual double	attack_direct_power_coefficient (const action_state_t *) const

virtual double	amount_delta_modifier (const action_state_t *) const

virtual double	attack_tick_power_coefficient (const action_state_t *) const

virtual double	spell_direct_power_coefficient (const action_state_t *) const

virtual double	spell_tick_power_coefficient (const action_state_t *) const

virtual double	base_da_min (const action_state_t *) const

virtual double	base_da_max (const action_state_t *) const

virtual double	base_ta (const action_state_t *) const

virtual double	bonus_ta (const action_state_t *) const

virtual double	range_ () const

virtual double	radius_ () const

virtual double	action_da_multiplier () const

virtual double	action_ta_multiplier () const

virtual double	composite_crit_damage_bonus_multiplier () const

virtual attack_power_type	get_attack_power_type () const

virtual double	composite_attack_power () const

virtual double	composite_spell_power () const

virtual double	composite_target_armor (player_t *t) const

virtual double	composite_target_crit_chance (player_t *target) const

virtual double	composite_target_crit_damage_bonus_multiplier (player_t *) const

virtual double	composite_target_damage_vulnerability (player_t *target) const

virtual double	composite_leech (const action_state_t *) const

virtual double	composite_run_speed () const

virtual double	composite_avoidance () const

virtual double	composite_corruption () const

virtual double	composite_corruption_resistance () const

virtual double	composite_total_corruption () const

virtual double	composite_target_da_multiplier (player_t *target) const
	Direct amount multiplier due to debuffs on the target.

virtual double	composite_target_ta_multiplier (player_t *target) const
	Tick amount multiplier due to debuffs on the target.

virtual double	composite_da_multiplier (const action_state_t *) const

virtual double	composite_ta_multiplier (const action_state_t *) const
	Normal ticking modifiers that are updated every tick.

virtual double	composite_persistent_multiplier (const action_state_t *) const
	Persistent modifiers that are snapshot at the start of the spell cast.

virtual double	composite_aoe_multiplier (const action_state_t *) const
	Generic aoe multiplier for the action. More...

virtual double	composite_target_mitigation (player_t *t, school_e s) const

virtual double	composite_player_critical_multiplier (const action_state_t *s) const

virtual proc_types	proc_type () const
	Action proc type, needed for dynamic aoe stuff and such.

virtual bool	has_movement_directionality () const

virtual double	composite_teleport_distance (const action_state_t *) const

virtual timespan_t	calculate_dot_refresh_duration (const dot_t *, timespan_t triggered_duration) const
	Calculates the new dot length after a refresh Necessary because we have both pandemic behaviour ( last 30% of the dot are preserved ) and old Cata/MoP behavior ( only time to the next tick is preserved )

virtual bool	dot_refreshable (const dot_t *dot, timespan_t triggered_duration) const

virtual double	composite_energize_amount (const action_state_t *) const

virtual resource_e	energize_resource_ () const

virtual action_energize	energize_type_ () const

virtual gain_t *	energize_gain (const action_state_t *) const

virtual void	parse_options (util::string_view options_str)

virtual void	consume_resource ()

virtual void	tick (dot_t *d)

virtual void	last_tick (dot_t *d)

virtual void	assess_damage (result_amount_type, action_state_t *state)

virtual void	record_data (action_state_t *data)

virtual void	schedule_execute (action_state_t *state=nullptr)

virtual void	queue_execute (execute_type type)

virtual void	reschedule_execute (timespan_t time)

virtual void	start_gcd ()

virtual void	update_ready (timespan_t cd_duration=timespan_t::min())

virtual bool	ready ()
	Is the ability ready based on spell characteristics.

virtual bool	action_ready ()
	Is the action ready, as a combination of ability characteristics and user input? Main ntry-point when selecting something to do for an actor. More...

virtual bool	select_target ()
	Select a target to execute on.

virtual bool	target_ready (player_t *target)
	Target readiness state checking.

virtual bool	usable_during_current_cast () const
	Ability usable during an on-going cast.

virtual bool	usable_during_current_gcd () const
	Ability usable during the on-going global cooldown.

virtual void	init_finished ()

virtual void	cancel ()

virtual void	interrupt_action ()

virtual void	activate ()

virtual std::unique_ptr< expr_t >	create_expression (util::string_view name)

virtual action_state_t *	new_state ()

virtual void	do_schedule_travel (action_state_t *, timespan_t)

virtual void	schedule_travel (action_state_t *)

virtual void	impact (action_state_t *)

virtual void	trigger_dot (action_state_t *)

virtual void	snapshot_internal (action_state_t *, unsigned flags, result_amount_type)

virtual void	snapshot_state (action_state_t *s, unsigned flags, result_amount_type rt)

virtual void	snapshot_state (action_state_t *s, result_amount_type rt)

virtual void	update_state (action_state_t *s, unsigned flags, result_amount_type rt)

virtual void	update_state (action_state_t *s, result_amount_type rt)

event_t *	start_action_execute_event (timespan_t time, action_state_t *state=nullptr)

virtual bool	consume_cost_per_tick (const dot_t &dot)
	If the action is still ticking and all resources could be successfully consumed, return true to indicate continued ticking.

virtual void	do_teleport (action_state_t *)

virtual dot_t *	get_dot (player_t *=nullptr)

virtual void	acquire_target (retarget_source, player_t , player_t )
	Acquire a new target, where the context is the actor that sources the retarget event, and the actor-level candidate is given as a parameter (selected by player_t::acquire_target). More...

virtual void	set_target (player_t *target)

virtual void	gain_energize_resource (resource_e resource_type, double amount, gain_t *gain)

Public Attributes
double	base_attack_expertise

Public Attributes inherited from action_t
const spell_data_t *	s_data

const spell_data_t *	s_data_reporting

sim_t *	sim

const action_e	type

std::string	name_str

std::string	name_str_reporting

player_t *const	player

player_t *	target

const item_t *	item
	Item back-pointer for trinket-sourced actions so we can show proper tooltips in reports.

weapon_t *	weapon
	Weapon used for this ability. If set extra weapon damage is calculated.

player_t *	default_target
	Default target is needed, otherwise there's a chance that cycle_targets option will MAJORLY mess up the action list for the actor, as there's no guarantee cycle_targets will end up on the "initial target" when an iteration ends.

school_e	school
	What type of damage this spell does.

std::vector< school_e >	base_schools
	What base school components this spell has.

unsigned	id
	Spell id if available, 0 otherwise.

int	internal_id
	player & action-name unique id. More...

resource_e	resource_current
	What resource does this ability use.

int	aoe
	The amount of targets that an ability impacts on. -1 will hit all targets.

bool	dual
	If set to true, this action will not be counted toward total amount of executes in reporting. Useful for abilities with parent/children attacks.

bool	callbacks
	enables/disables proc callback system on the action, like trinkets, enchants, rppm.

bool	allow_class_ability_procs
	Allows triggering of procs marked to only proc from class abilities.

bool	not_a_proc
	Specifies that a spell is not a proc and can be considered for triggering only proc from class abilities procs even if it is a background ability.

bool	special
	Whether or not the spell uses the yellow attack hit table.

bool	channeled
	Tells the sim to not perform any other actions, as the ability is channeled.

bool	sequence
	mark this as a sequence_t action

bool	quiet
	Disables/enables reporting of this action. More...

bool	background
	Enables/Disables direct execution of the ability in an action list. More...

bool	use_off_gcd
	Check if action is executable between GCD's. More...

bool	use_while_casting
	True if ability should be used while casting another spell.

bool	usable_while_casting
	True if ability is usable while casting another spell.

bool	interrupt_auto_attack
	False if channeled action does not reschedule autoattacks, used on abilities such as bladestorm.

bool	reset_auto_attack
	True if channeled action fully resets the autoattack timer rather than simply delaying it.

bool	ignore_false_positive
	Used for actions that will do awful things to the sim when a "false positive" skill roll happens.

double	action_skill
	Skill is now done per ability, with the default being set to the player option.

bool	direct_tick
	Used with DoT Drivers, tells simc that the direct hit is actually a tick.

bool	ignores_armor
	Used with psudo-DoT effects, tells us to ignore armor even if the physical damage is direct.

bool	repeating
	Used for abilities that repeat themselves without user interaction, only used on autoattacks.

bool	harmful
	Simplified: Will the ability pull the boss if used. More...

bool	proc
	Whether or not this ability is a proc. More...

bool	is_interrupt
	Whether or not the action is an interrupt (specifically triggers PF2_CAST_INTERRUPT callbacks)

bool	is_precombat
	Whether the action is used from the precombat action list. Will be set up automatically by action_t::init_finished.

bool	initialized
	Is the action initialized? (action_t::init ran successfully)

bool	may_hit
	Self explanatory.

bool	may_miss

bool	may_dodge

bool	may_parry

bool	may_glance

bool	may_block

bool	may_crit

bool	tick_may_crit

bool	tick_zero
	Whether or not the ability/dot ticks immediately on usage.

bool	tick_on_application
	Whether or not the ability/dot ticks when it is first applied, but not on refresh applications.

bool	hasted_ticks
	Whether or not ticks scale with haste. More...

bool	consume_per_tick_
	Need to consume per tick?

bool	split_aoe_damage
	Split damage evenly between targets.

double	reduced_aoe_targets
	Reduce damage to targets when total targets is greater than value Formula used is <damage per="" target>=""> = sqrt( reduced_aoe_targets / <number of="" targets>=""> )

int	full_amount_targets
	If reduced_aoe_targets > 0, the number of target(s) that will take full unreduced amount.

bool	normalize_weapon_speed
	Normalize weapon speed for weapon damage calculations. More...

bool	ground_aoe
	This ability leaves a ticking dot on the ground, and doesn't move when the target moves. Used with original_x and original_y.

bool	round_base_dmg
	Round spell base damage to integer before using.

bool	dynamic_tick_action
	Used with tick_action, tells tick_action to update state on every tick.

bool	interrupt_immediate_occurred
	Did a channel action have an interrupt_immediate used to cancel it on it.

bool	hit_any_target

timespan_t	ground_aoe_duration
	Duration of the ground area trigger.

attack_power_type	ap_type
	Type of attack power used by the ability.

dot_behavior_e	dot_behavior
	Behavior of dot. More...

timespan_t	ability_lag
	Ability specific extra player ready delay.

timespan_t	ability_lag_stddev

timespan_t	min_gcd
	The minimum gcd triggered no matter the haste.

gcd_haste_type	gcd_type
	Hasted GCD stat type. One of HASTE_NONE, HASTE_ATTACK, HASTE_SPELL, SPEED_ATTACK, SPEED_SPELL.

timespan_t	trigger_gcd
	Length of unhasted gcd triggered when used.

double	range
	This is how far away the target can be from the player, and still be hit or targeted.

double	radius
	AoE ability area of influence. More...

double	weapon_power_mod
	Weapon AP multiplier.

struct {
double direct

double tick

}	attack_power_mod
	Attack/Spell power scaling of the ability.

struct {
double direct

double tick

}	spell_power_mod

double	amount_delta
	full damage variation in % More...

timespan_t	base_execute_time
	Amount of time the ability uses to execute before modifiers.

timespan_t	base_tick_time
	Amount of time the ability uses between ticks.

timespan_t	dot_duration
	Default full duration of dot.

int	dot_max_stack

std::array< double, RESOURCE_MAX >	base_costs
	Cost of using the ability.

std::array< double, RESOURCE_MAX >	secondary_costs

std::array< double, RESOURCE_MAX >	base_costs_per_tick
	Cost of using ability per periodic effect tick.

double	base_dd_min
	Minimum base direct damage.

double	base_dd_max
	Maximum base direct damage.

double	base_td
	Base tick damage.

double	base_dd_multiplier
	base direct damage multiplier

double	base_td_multiplier
	base tick damage multiplier

double	base_multiplier
	base damage multiplier (direct and tick damage)

double	base_hit

double	base_crit

double	crit_multiplier

double	crit_bonus_multiplier

double	crit_bonus

double	base_dd_adder

double	base_ta_adder

double	weapon_multiplier
	Weapon damage for the ability.

double	chain_multiplier
	Damage modifier for chained/AoE, exponentially increased by number of target hit.

double	chain_bonus_damage
	Damage modifier for chained/AoE, linearly increasing with each target hit.

double	base_aoe_multiplier
	Static reduction of damage for AoE.

double	base_recharge_multiplier
	Static action cooldown duration multiplier.

double	base_recharge_rate_multiplier
	A second static action cooldown duration multiplier that also reduces the effectiveness of flat cooldown adjustments.

double	dynamic_recharge_multiplier
	Dynamically adjustable action cooldown duration multipliers. These are reset to 1.0 in action_t::reset.

double	dynamic_recharge_rate_multiplier

double	base_teleport_distance
	Maximum distance that the ability can travel. Used on abilities that instantly move you, or nearly instantly move you to a location.

double	travel_speed
	Missile travel speed in yards / second.

double	travel_delay
	Missile travel delay in seconds.

double	min_travel_time
	Minimum travel time in seconds.

double	energize_amount

movement_direction_type	movement_directionality
	Movement Direction. More...

dot_t *	parent_dot
	This is used to cache/track spells that have a parent driver, such as most channeled/ground aoe abilities.

std::vector< action_t *>	child_action

action_t *	tick_action
	This action will execute every tick.

action_t *	execute_action
	This action will execute every execute.

action_t *	impact_action
	This action will execute every impact - Useful for AoE debuffs.

gain_t *	gain

action_energize	energize_type

resource_e	energize_resource

cooldown_t *	cooldown
	Used to manipulate cooldown duration and charges. More...

cooldown_t *	internal_cooldown

stats_t *	stats
	action statistics, merged by action-name

event_t *	execute_event
	Execute event (e.g., "casting" of the action)

event_t *	queue_event
	Queue delay event (for queueing cooldowned actions shortly before they execute. More...

timespan_t	time_to_execute
	Last available, effectively used execute time.

timespan_t	time_to_travel
	Last available, effectively used travel time.

double	last_resource_cost
	Last available, effectively used resource cost.

int	num_targets_hit
	Last available number of targets effectively hit.

char	marker
	Marker for sample action priority list reporting.

timespan_t	last_used

struct action_t::options_t	option

bool	interrupt_global

std::unique_ptr< expr_t >	if_expr

enum action_t::target_if_mode_e	target_if_mode

std::unique_ptr< expr_t >	target_if_expr

std::unique_ptr< expr_t >	interrupt_if_expr

std::unique_ptr< expr_t >	early_chain_if_expr

std::unique_ptr< expr_t >	cancel_if_expr

action_t *	sync_action

std::string	signature_str

target_specific_t< dot_t >	target_specific_dot

action_priority_list_t *	action_list

proc_t *	starved_proc
	Resource starvation tracking. More...

proc_t *	queue_failed_proc

uint_least64_t	total_executions

std::unique_ptr< cooldown_t >	line_cooldown
	Cooldown for specific APL line. More...

const action_priority_t *	signature

action_state_t *	execute_state
	State of the last execute()

action_state_t *	pre_execute_state
	Optional - if defined before execute(), will be copied into execute_state.

unsigned	snapshot_flags

unsigned	update_flags

struct action_t::target_cache_t	target_cache

Additional Inherited Members
Public Types inherited from action_t
enum	target_if_mode_e { TARGET_IF_NONE, TARGET_IF_FIRST, TARGET_IF_MIN, TARGET_IF_MAX }

Static Public Member Functions inherited from action_t
static bool	result_is_hit (result_e r)

static bool	result_is_miss (result_e r)

static bool	result_is_block (block_result_e r)

Public Member Functions

Public Attributes

Additional Inherited Members