Inheritance diagram for buff_t:

Public Member Functions
	buff_t (actor_pair_t q, util::string_view name)

	buff_t (actor_pair_t q, util::string_view name, const spell_data_t , const item_t item=nullptr)

	buff_t (sim_t *sim, util::string_view name)

	buff_t (sim_t sim, util::string_view name, const spell_data_t , const item_t *item=nullptr)

const spell_data_t &	data () const

const spell_data_t &	data_reporting () const

int	check () const
	Get current number of stacks, no benefit tracking. More...

int	stack ()
	Get current number of stacks + benefit tracking. More...

bool	up ()
	Check if buff is up Use check() inside of ready() and cost() methods to prevent skewing of "benefit" calculations. More...

virtual double	value ()
	Get current buff value + benefit tracking.

double	stack_value ()
	Get current buff value multiplied by current stacks + benefit tracking.

double	check_value () const
	Get current buff value + NO benefit tracking.

double	check_stack_value () const
	Get current buff value multiplied by current stacks + NO benefit tracking.

virtual bool	freeze_stacks ()
	Return true if tick should not call bump() or decrement()

virtual timespan_t	buff_duration () const

timespan_t	remains () const

timespan_t	tick_time_remains () const

timespan_t	elapsed (timespan_t t) const

timespan_t	last_trigger_time () const

timespan_t	last_expire_time () const

bool	remains_gt (timespan_t time) const

bool	remains_lt (timespan_t time) const

bool	has_common_school (school_e) const

bool	at_max_stacks (int mod=0) const

int	_resolve_stacks (int stacks)

bool	trigger (action_t *, int stacks=-1, double value=DEFAULT_VALUE(), timespan_t duration=timespan_t::min())

bool	trigger (timespan_t duration)

bool	trigger (int stacks, timespan_t duration)

virtual bool	trigger (int stacks=-1, double value=DEFAULT_VALUE(), double chance=-1.0, timespan_t duration=timespan_t::min())

virtual void	execute (int stacks=-1, double value=DEFAULT_VALUE(), timespan_t duration=timespan_t::min())

virtual void	increment (int stacks=1, double value=DEFAULT_VALUE(), timespan_t duration=timespan_t::min())

virtual void	decrement (int stacks=1, double value=DEFAULT_VALUE())

virtual void	extend_duration (player_t *p, timespan_t seconds)

virtual void	extend_duration_or_trigger (timespan_t duration=timespan_t::min(), player_t *p=nullptr)

virtual void	start (int stacks=1, double value=DEFAULT_VALUE(), timespan_t duration=timespan_t::min())

virtual void	refresh (int stacks=0, double value=DEFAULT_VALUE(), timespan_t duration=timespan_t::min())

virtual void	bump (int stacks=1, double value=DEFAULT_VALUE())

virtual void	override_buff (int stacks=1, double value=DEFAULT_VALUE())

virtual bool	may_react (int stacks=1)

virtual int	stack_react ()

virtual void	expire (timespan_t delay=timespan_t::zero())

void	cancel ()

virtual void	expire_override (int, timespan_t)

virtual void	predict ()

virtual void	reset ()

virtual void	aura_gain ()

virtual void	aura_loss ()

virtual void	merge (const buff_t &other_buff)

virtual void	analyze ()

virtual void	datacollection_begin ()

virtual void	datacollection_end ()

virtual timespan_t	refresh_duration (timespan_t new_duration) const

virtual timespan_t	tick_time () const

void	invalidate_cache ()

virtual int	total_stack ()

std::string	to_str () const

const char *	name () const

const char *	name_reporting () const

util::string_view	source_name () const

int	max_stack () const

int	initial_stack () const

const spell_data_t *	get_trigger_data () const

rng::rng_t &	rng ()

buff_t *	set_chance (double chance)

buff_t *	set_duration (timespan_t duration)

buff_t *	modify_duration (timespan_t duration)

buff_t *	set_duration_multiplier (double)

buff_t *	set_max_stack (int max_stack)

buff_t *	modify_max_stack (int max_stack)

buff_t *	set_initial_stack (int initial_stack)

buff_t *	modify_initial_stack (int initial_stack)

buff_t *	set_expire_at_max_stack (bool)

buff_t *	set_cooldown (timespan_t duration)

buff_t *	modify_cooldown (timespan_t duration)

buff_t *	set_period (timespan_t)

buff_t *	set_quiet (bool quiet)

buff_t *	add_invalidate (cache_e)

buff_t *	set_schools (unsigned)

buff_t *	set_schools_from_effect (size_t)

buff_t *	add_school (school_e)

buff_t *	set_pct_buff_type (stat_pct_buff_type)

buff_t *	set_default_value (double, size_t=0)

virtual buff_t *	set_default_value_from_effect (size_t, double=0.0)

virtual buff_t *	set_default_value_from_effect_type (effect_subtype_t a_type, property_type_t p_type=P_MAX, double multiplier=0.0, effect_type_t e_type=E_APPLY_AURA)

buff_t *	modify_default_value (double)

buff_t *	set_reverse (bool)

buff_t *	set_activated (bool)

buff_t *	set_can_cancel (bool cc)

buff_t *	set_tick_behavior (buff_tick_behavior)

buff_t *	set_tick_callback (buff_tick_callback_t)

buff_t *	set_tick_time_callback (buff_tick_time_callback_t)

buff_t *	set_affects_regen (bool state)

buff_t *	set_constant_behavior (buff_constant_behavior)

buff_t *	set_refresh_behavior (buff_refresh_behavior)

buff_t *	set_refresh_duration_callback (buff_refresh_duration_callback_t)

buff_t *	set_tick_zero (bool v)

buff_t *	set_tick_on_application (bool v)

buff_t *	set_partial_tick (bool v)

buff_t *	set_tick_time_behavior (buff_tick_time_behavior b)

buff_t *	set_rppm (rppm_scale_e scale=RPPM_NONE, double freq=-1, double mod=-1)

buff_t *	set_trigger_spell (const spell_data_t *s)

buff_t *	set_stack_change_callback (const buff_stack_change_callback_t &cb)

buff_t *	set_reverse_stack_count (int count)

buff_t *	set_stack_behavior (buff_stack_behavior b)

buff_t *	set_allow_precombat (bool b)

buff_t *	set_name_reporting (std::string_view)

virtual buff_t *	apply_affecting_aura (const spell_data_t *spell)

virtual buff_t *	apply_affecting_effect (const spelleffect_data_t &effect)

virtual buff_t *	apply_affecting_conduit (const conduit_data_t &conduit, int effect_num=1)

virtual buff_t *	apply_affecting_conduit_effect (const conduit_data_t &conduit, size_t effect_num)

Static Public Member Functions
static std::unique_ptr< expr_t >	create_expression (util::string_view buff_name, util::string_view type, action_t &action)

static std::unique_ptr< expr_t >	create_expression (util::string_view buff_name, util::string_view type, buff_t &static_buff)

static double	DEFAULT_VALUE ()

static buff_t *	find (util::span< buff_t const >, util::string_view name, player_t source=nullptr)

static buff_t *	find (sim_t *, util::string_view name)

static buff_t *	find (player_t , util::string_view name, player_t source=nullptr)

static buff_t *	find_expressable (util::span< buff_t const >, util::string_view name, player_t source=nullptr)

Public Attributes
sim_t *const	sim

player_t *const	player

const item_t *const	item

const std::string	name_str

std::string	name_str_reporting

const spell_data_t *	s_data

const spell_data_t *	s_data_reporting

player_t *const	source

std::vector< event_t * >	expiration

event_t *	delay

event_t *	expiration_delay

cooldown_t *	cooldown

sc_timeline_t	uptime_array

real_ppm_t *	rppm

double	default_value

size_t	default_value_effect_idx

double	default_value_effect_multiplier

unsigned	schools

bool	activated
	Is buff manually activated or not (eg. More...

bool	reactable

bool	reverse

bool	constant

bool	quiet

bool	overridden

bool	can_cancel

bool	requires_invalidation

bool	expire_at_max_stack

int	reverse_stack_reduction

double	current_value
	Number of stacks reduced when reverse = true.

int	current_stack

timespan_t	base_buff_duration

double	buff_duration_multiplier

double	default_chance

double	manual_chance

std::vector< timespan_t >	stack_react_time

std::vector< event_t * >	stack_react_ready_triggers

buff_constant_behavior	constant_behavior

buff_refresh_behavior	refresh_behavior

buff_refresh_duration_callback_t	refresh_duration_callback

buff_stack_behavior	stack_behavior

buff_stack_change_callback_t	stack_change_callback

bool	allow_precombat

unsigned	current_tick

timespan_t	buff_period

buff_tick_time_behavior	tick_time_behavior

buff_tick_behavior	tick_behavior

event_t *	tick_event

buff_tick_callback_t	tick_callback

buff_tick_time_callback_t	tick_time_callback

bool	tick_zero

bool	tick_on_application

bool	partial_tick

simple_sample_data_t	benefit_pct

simple_sample_data_t	trigger_pct

simple_sample_data_t	avg_start

simple_sample_data_t	avg_refresh

simple_sample_data_t	avg_expire

simple_sample_data_t	avg_overflow_count

simple_sample_data_t	avg_overflow_total

simple_sample_data_t	uptime_pct

simple_sample_data_with_min_max_t	start_intervals

simple_sample_data_with_min_max_t	trigger_intervals

simple_sample_data_with_min_max_t	duration_lengths

std::vector< uptime_simple_t >	stack_uptime

bool	change_regen_rate

Protected Member Functions
	buff_t (sim_t sim, player_t target, player_t source, util::string_view name, const spell_data_t , const item_t *item)

void	update_stack_uptime_array (timespan_t current_time, int old_stacks)

Protected Attributes
timespan_t	last_start

timespan_t	last_trigger

timespan_t	last_expire

timespan_t	last_stack_change

timespan_t	iteration_uptime_sum

timespan_t	last_benefite_update

unsigned int	up_count

unsigned int	down_count

unsigned int	start_count

unsigned int	refresh_count

unsigned int	expire_count

unsigned int	overflow_count

unsigned int	overflow_total

int	trigger_attempts

int	trigger_successes

int	simulation_max_stack

std::vector< cache_e >	invalidate_list

gcd_haste_type	gcd_type

Friends
void	sc_format_to (const buff_t &, fmt::format_context::iterator)

Member Function Documentation

◆ check()

int buff_t::check ( ) const

inline

Get current number of stacks, no benefit tracking.

Use check() inside of ready() and cost() methods to prevent skewing of "benefit" calculations. Use up() where the presence of the buff affects the action mechanics.

◆ stack()

int buff_t::stack ( )

Get current number of stacks + benefit tracking.

Use check() inside of ready() and cost() methods to prevent skewing of "benefit" calculations. This will only modify the benefit counters once per sim time unit. Use up()/down where the presence of the buff affects the action mechanics.

◆ up()

bool buff_t::up ( )

inline

Check if buff is up Use check() inside of ready() and cost() methods to prevent skewing of "benefit" calculations.

Use up()/down where the presence of the buff affects the action mechanics.

Member Data Documentation

◆ activated

bool buff_t::activated

Is buff manually activated or not (eg.

a proc). non-activated player buffs have a delayed trigger event

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions