void action_t::execute()
{
if ( sim -> log && ! dual )
{
log_t::output( sim, "%s performs %s (%.0f)", player -> name(), name(),
player -> resource_current[ player -> primary_resource() ] );
}
if ( observer ) *observer = 0;
player_buff();
target_debuff( DMG_DIRECT );
calculate_result();
consume_resource();
if ( result_is_hit() )
{
calculate_direct_damage();
if ( direct_dmg > 0 )
{
assess_damage( direct_dmg, DMG_DIRECT );
}
if ( num_ticks > 0 )
{
if ( dot_behavior == DOT_REFRESH )
{
current_tick = 0;
if ( ! ticking ) schedule_tick();
}
else
{
if ( ticking ) cancel();
snapshot_haste = haste();
schedule_tick();
}
}
}
else
{
if ( sim -> log )
{
log_t::output( sim, "%s avoids %s (%s)", sim -> target -> name(), name(), util_t::result_type_string( result ) );
log_t::miss_event( this );
}
}
update_ready();
if ( ! dual ) update_stats( DMG_DIRECT );
schedule_travel();
if ( repeating && ! proc ) schedule_execute();
if ( harmful ) player -> in_combat = true;
}
void absorb_t::impact( player_t* t, int impact_result, double travel_dmg=0 )
{
if ( travel_dmg > 0 )
{
assess_damage( t, travel_dmg, ABSORB, impact_result );
}
}
void heal_t::tick( dot_t* d )
{
if ( sim -> debug )
log_t::output( sim, "%s ticks (%d of %d)", name(), d -> current_tick, d -> num_ticks );
result = RESULT_HIT;
player_tick();
target_debuff( heal_target[0], HEAL_OVER_TIME );
if ( tick_may_crit )
{
if ( rng[ RESULT_CRIT ] -> roll( crit_chance( 0 ) ) )
{
result = RESULT_CRIT;
}
}
tick_dmg = calculate_tick_damage();
assess_damage( heal_target[0], tick_dmg, HEAL_OVER_TIME, result );
if ( callbacks ) action_callback_t::trigger( player -> tick_callbacks[ result ], this );
stats -> add_tick( d -> time_to_tick );
}
void heal_t::impact( player_t* t, int impact_result, double travel_heal=0 )
{
assess_damage( t, travel_heal, HEAL_DIRECT, impact_result );
if ( num_ticks > 0 )
{
if ( dot_behavior != DOT_REFRESH ) dot -> cancel();
dot -> action = this;
dot -> num_ticks = hasted_num_ticks();
dot -> current_tick = 0;
dot -> added_ticks = 0;
if ( dot -> ticking )
{
assert( dot -> tick_event );
if ( ! channeled )
{
// Recasting a dot while it's still ticking gives it an extra tick in total
dot -> num_ticks++;
}
}
else
{
dot -> schedule_tick();
}
dot -> recalculate_ready();
if ( sim -> debug )
log_t::output( sim, "%s extends dot-ready to %.2f for %s (%s)",
player -> name(), dot -> ready, name(), dot -> name() );
}
}
void action_t::tick()
{
if ( sim -> debug ) log_t::output( sim, "%s ticks (%d of %d)", name(), current_tick, num_ticks );
result = RESULT_HIT;
// Older tests indicated that crit debuffs are calculated at the time of the cast, not the ticks.
// It's possible that this has now changed, but would require testing to be certain.
double save_target_crit = target_crit;
target_debuff( DMG_OVER_TIME );
target_crit = save_target_crit;
if ( tick_may_crit )
{
int delta_level = sim -> target -> level - player -> level;
if ( rng[ RESULT_CRIT ] -> roll( crit_chance( delta_level ) ) )
{
result = RESULT_CRIT;
action_callback_t::trigger( player -> spell_result_callbacks[ RESULT_CRIT ], this );
if ( channeled )
{
action_callback_t::trigger( player -> spell_direct_result_callbacks[ RESULT_CRIT ], this );
}
}
}
calculate_tick_damage();
assess_damage( tick_dmg, DMG_OVER_TIME );
action_callback_t::trigger( player -> tick_callbacks, this );
update_stats( DMG_OVER_TIME );
}
void absorb_t::impact( action_state_t* s )
{
assess_damage( type == ACTION_HEAL ? HEAL_DIRECT : DMG_DIRECT, s );
}
