action.hpp

// ==========================================================================
// Dedmonwakeen's Raid DPS/TPS Simulator.
// Send questions to [email protected]
// ==========================================================================

#pragma once

#include "config.hpp"
#include "dbc/data_definitions.hh"
#include "player/target_specific.hpp"
#include "sc_enums.hpp"
#include "util/timespan.hpp"
#include "util/generic.hpp"
#include "util/string_view.hpp"
#include "util/format.hpp"

#include <array>
#include <vector>
#include <memory>
#include <string>

struct action_priority_t;
struct action_priority_list_t;
struct action_state_t;
struct spell_data_t;
struct cooldown_t;
class conduit_data_t;
struct dot_t;
struct event_t;
struct expr_t;
struct gain_t;
struct item_t;
struct option_t;
struct sim_t;
struct player_t;
struct proc_t;
namespace rng {
  struct rng_t;
}
struct spelleffect_data_t;
struct stats_t;
struct travel_event_t;
struct weapon_t;

// Action ===================================================================

struct action_t : private noncopyable
{
public:
  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;

  weapon_t* weapon;

  player_t* default_target;

  school_e school;

  std::vector<school_e> base_schools;

  unsigned id;

  int internal_id;

  resource_e resource_current;

  int aoe;

  bool dual;

  bool callbacks;

  bool allow_class_ability_procs;

  bool not_a_proc;

  bool special;

  bool channeled;

  bool sequence;

  bool quiet;

  bool background;

  bool use_off_gcd;

  bool use_while_casting;

  bool usable_while_casting;

  bool interrupt_auto_attack;

  bool reset_auto_attack;

  bool ignore_false_positive;

  double action_skill;

  bool direct_tick;

  bool ignores_armor;

  bool repeating;

  bool harmful;

  bool proc;

  bool is_interrupt;

  bool is_precombat;

  bool initialized;

  bool may_hit, may_miss, may_dodge, may_parry, may_glance, may_block, may_crit, tick_may_crit;

  bool tick_zero;

  bool tick_on_application;

  bool hasted_ticks;

  bool consume_per_tick_;

  bool split_aoe_damage;

  double reduced_aoe_targets;

  int full_amount_targets;

  bool normalize_weapon_speed;

  bool ground_aoe;

  bool round_base_dmg;

  bool dynamic_tick_action;


  bool interrupt_immediate_occurred;

  bool hit_any_target;

  timespan_t ground_aoe_duration;

  attack_power_type ap_type;

  dot_behavior_e dot_behavior;

  timespan_t ability_lag, ability_lag_stddev;

  timespan_t min_gcd;

  gcd_haste_type gcd_type;

  timespan_t trigger_gcd;

  double range;

  double radius;

  double weapon_power_mod;

  struct {
  double direct, tick;
  } attack_power_mod, spell_power_mod;

  double amount_delta;

  timespan_t base_execute_time;

  timespan_t base_tick_time;

  timespan_t dot_duration;

  // Maximum number of DoT stacks.
  int dot_max_stack;

  std::array< double, RESOURCE_MAX > base_costs, secondary_costs;

  std::array< double, RESOURCE_MAX > base_costs_per_tick;

  double base_dd_min;

  double base_dd_max;

  double base_td;

  double base_dd_multiplier;

  double base_td_multiplier;

  double base_multiplier;

  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;

  double chain_multiplier;

  double chain_bonus_damage;

  double base_aoe_multiplier;

  double base_recharge_multiplier;

  double base_recharge_rate_multiplier;

  double dynamic_recharge_multiplier;
  double dynamic_recharge_rate_multiplier;

  double base_teleport_distance;

  double travel_speed;

  double travel_delay;

  double min_travel_time;

  // Amount of resource for the energize to grant.
  double energize_amount;

  movement_direction_type movement_directionality;

  dot_t* parent_dot;

  std::vector< action_t* > child_action;

  action_t* tick_action;

  action_t* execute_action;

  action_t* impact_action;

  // Gain object of the same name as the action
  gain_t* gain;

  // Sets the behavior for when this action's resource energize occur.
  action_energize energize_type;

  // Resource for the energize to grant.
  resource_e energize_resource;

  cooldown_t* cooldown, *internal_cooldown;

  stats_t* stats;

  event_t* execute_event;

  event_t* queue_event;

  timespan_t time_to_execute;

  timespan_t time_to_travel;

  double last_resource_cost;

  int num_targets_hit;

  char marker;

  /* The last time the action was executed */
  timespan_t last_used;

  // Options
  struct options_t {
    int moving;

    int wait_on_ready;

    int max_cycle_targets;

    int target_number;

    bool interrupt;

    bool chain;

    int cycle_targets;

    bool cycle_players;

    bool interrupt_immediate;

    std::string if_expr_str;
    std::string target_if_str;
    std::string interrupt_if_expr_str;
    std::string early_chain_if_expr_str;
    std::string cancel_if_expr_str;
    std::string sync_str;
    std::string target_str;
    options_t();
  } option;

  bool interrupt_global;

  std::unique_ptr<expr_t> if_expr;

  enum target_if_mode_e
  {
    TARGET_IF_NONE,
    TARGET_IF_FIRST,
    TARGET_IF_MIN,
    TARGET_IF_MAX
  } 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;

  // Tracking proc triggered when action fails to execute after being queued.
  // Can be overridden by class modules for tracking purposes.
  proc_t* queue_failed_proc;
  uint_least64_t total_executions;

  std::unique_ptr<cooldown_t> line_cooldown;
  const action_priority_t* signature;


  action_state_t* execute_state;

  action_state_t* pre_execute_state;

  unsigned snapshot_flags;

  unsigned update_flags;

  struct target_cache_t {
    std::vector< player_t* > list;
    bool is_valid;
    target_cache_t() : is_valid( false ) {}
  } mutable target_cache;

private:
  std::vector<std::unique_ptr<option_t>> options;
  action_state_t* state_cache;
  std::vector<travel_event_t*> travel_events;
public:
  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 );

  virtual ~action_t();

  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
  { return ( *s_data ); }

  // return s_data_reporting if available, otherwise fallback to s_data
  const spell_data_t& data_reporting() const;

  dot_t* find_dot( player_t* target ) const;

  bool is_aoe() const
  {
    const int num_targets = n_targets();
    return num_targets == -1 || num_targets > 0;
  }

  const char* name() const
  { return name_str.c_str(); }

  const char* name_reporting() const;

  size_t num_travel_events() const
  { return travel_events.size(); }

  bool has_travel_events() const
  { return ! travel_events.empty(); }

  timespan_t shortest_travel_event() const;

  bool has_travel_events_for( const player_t* target ) const;

  virtual bool has_amount_result() const
  {
    return attack_power_mod.direct > 0 || attack_power_mod.tick > 0
        || spell_power_mod.direct > 0 || spell_power_mod.tick > 0
        || (weapon && weapon_multiplier > 0);
  }

  void parse_spell_data( const spell_data_t& );

  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 );

private:
  friend struct action_state_t;
  void release_state( action_state_t* );

public:

  // =======================
  // Const virtual functions
  // =======================

  virtual bool verify_actor_level() const;

  virtual bool verify_actor_spec() const;

  virtual bool verify_actor_weapon() const;

  virtual double cost() const;

  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;

  virtual double false_negative_pct() const;

  virtual timespan_t execute_time() const
  { return base_execute_time; }

  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 result_e calculate_result( action_state_t* /* state */ ) const
  {
    assert( false );
    return RESULT_UNKNOWN;
  }

  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_multiplier( const cooldown_t& ) const
  { return base_recharge_multiplier * dynamic_recharge_multiplier; }

  virtual double recharge_rate_multiplier( const cooldown_t& ) const
  { return base_recharge_rate_multiplier * dynamic_recharge_rate_multiplier; }

  virtual timespan_t cooldown_base_duration( const cooldown_t& cd ) const;

  virtual resource_e current_resource() const
  { return resource_current; }

  virtual int n_targets() const
  { return aoe; }

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

  virtual result_amount_type amount_type( const action_state_t* /* state */, bool /* periodic */ = false ) const
  { return result_amount_type::NONE; }

  virtual result_amount_type report_amount_type( const action_state_t* state ) const;

  virtual school_e get_school() const
  { return school; }

  virtual double miss_chance( double /* hit */, player_t* /* target */ ) const
  { return 0; }

  virtual double dodge_chance( double /* expertise */, player_t* /* target */ ) const
  { return 0; }

  virtual double parry_chance( double /* expertise */, player_t* /* target */ ) const
  { return 0; }

  virtual double glance_chance( int /* delta_level */ ) const
  { return 0; }

  virtual double block_chance( action_state_t* /* state */ ) const
  { return 0; }

  virtual double crit_block_chance( action_state_t* /* state */  ) const
  { return 0; }

  virtual double total_crit_bonus( const action_state_t* /* state */ ) const; // Check if we want to move this into the stateless system.

  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
  { return attack_power_mod.direct; }

  virtual double amount_delta_modifier( const action_state_t* ) const
  { return amount_delta; }

  virtual double attack_tick_power_coefficient( const action_state_t* ) const
  { return attack_power_mod.tick; }

  virtual double spell_direct_power_coefficient( const action_state_t* ) const
  { return spell_power_mod.direct; }

  virtual double spell_tick_power_coefficient( const action_state_t* ) const
  { return spell_power_mod.tick; }

  virtual double base_da_min( const action_state_t* ) const
  { return base_dd_min; }

  virtual double base_da_max( const action_state_t* ) const
  { return base_dd_max; }

  virtual double base_ta( const action_state_t* ) const
  { return base_td; }

  virtual double bonus_da( const action_state_t* ) const
  { return base_dd_adder; }

  virtual double bonus_ta( const action_state_t* ) const
  { return base_ta_adder; }

  virtual double range_() const
  { return range; }

  virtual double radius_() const
  { return radius; }

  virtual double action_multiplier() const
  { return base_multiplier; }

  virtual double action_da_multiplier() const
  { return base_dd_multiplier; }

  virtual double action_ta_multiplier() const
  { return base_td_multiplier; }

  virtual double composite_hit() const
  { return base_hit; }

  virtual double composite_crit_chance() const
  { return base_crit; }

  virtual double composite_crit_chance_multiplier() const
  { return 1.0; }

  virtual double composite_crit_damage_bonus_multiplier() const
  { return crit_bonus_multiplier; }

  virtual double composite_haste() const
  { return 1.0; }

  virtual attack_power_type get_attack_power_type() const
  { return ap_type; }

  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
  { return 1.0; }

  virtual double composite_target_multiplier( player_t* target ) const;

  virtual double composite_target_damage_vulnerability( player_t* target ) const;

  virtual double composite_versatility( const action_state_t* ) const
  { return 1.0; }

  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
  { return composite_target_multiplier( target ); }

  virtual double composite_target_ta_multiplier( player_t* target ) const
  { return composite_target_multiplier( target ); }

  virtual double composite_da_multiplier(const action_state_t* /* s */) const;

  virtual double composite_ta_multiplier(const action_state_t* /* s */) const;

  virtual double composite_persistent_multiplier(const action_state_t*) const;

  virtual double composite_aoe_multiplier( const action_state_t* ) const
  { return 1.0; }

  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
  { return PROC1_INVALID; }

  virtual bool has_movement_directionality() const;

  virtual double composite_teleport_distance( const action_state_t* ) const
  { return base_teleport_distance; }

  virtual timespan_t calculate_dot_refresh_duration( const dot_t*, timespan_t triggered_duration ) const;

  // Helper for dot refresh expression, overridable on action level
  virtual bool dot_refreshable( const dot_t* dot, timespan_t triggered_duration ) const;

  virtual double composite_energize_amount( const action_state_t* ) const
  { return energize_amount; }

  virtual resource_e energize_resource_() const
  { return energize_resource; }

  virtual action_energize energize_type_() const
  { return energize_type; }

  virtual gain_t* energize_gain( const action_state_t* /* state */ ) const
  { return gain; }

  // ==========================
  // mutating virtual functions
  // ==========================

  virtual void parse_options( util::string_view options_str );

  virtual void consume_resource();

  virtual void execute();

  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();
  virtual bool action_ready();
  virtual bool select_target();
  virtual bool target_ready( player_t* target );

  virtual bool usable_during_current_cast() const;
  virtual bool usable_during_current_gcd() const;

  virtual void init();

  virtual void init_finished();

  virtual void reset();

  virtual void cancel();

  virtual void interrupt_action();

  // Perform activation duties for the action. This is used to "enable" the action when the actor
  // becomes active.
  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 )
  { snapshot_internal( s, flags, rt ); }

  virtual void snapshot_state( action_state_t* s, result_amount_type rt )
  { snapshot_state( s, snapshot_flags, rt ); }

  virtual void update_state( action_state_t* s, unsigned flags, result_amount_type rt )
  { snapshot_internal( s, flags, rt ); }

  virtual void update_state( action_state_t* s, result_amount_type rt )
  { update_state( s, update_flags, 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 );

  virtual void do_teleport( action_state_t* );

  virtual dot_t* get_dot( player_t* = nullptr );

  virtual void acquire_target( retarget_source /* event */, player_t* /* context */, player_t* /* candidate_target */ );

  virtual void set_target( player_t* target );

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

  // ================
  // Static functions
  // ================

  static bool result_is_hit( result_e r )
  {
    return( r == RESULT_HIT        ||
            r == RESULT_CRIT       ||
            r == RESULT_GLANCE     ||
            r == RESULT_NONE       );
  }

  static bool result_is_miss( result_e r )
  {
    return( r == RESULT_MISS   ||
            r == RESULT_DODGE  ||
            r == RESULT_PARRY );
  }

  static bool result_is_block( block_result_e r )
  {
    return( r == BLOCK_RESULT_BLOCKED || r == BLOCK_RESULT_CRIT_BLOCKED );
  }

  friend void sc_format_to( const action_t&, fmt::format_context::iterator );
};

struct call_action_list_t : public action_t
{
  action_priority_list_t* alist;

  call_action_list_t( player_t*, util::string_view );
  void execute() override
  { assert( 0 ); }
};

struct swap_action_list_t : public action_t
{
  action_priority_list_t* alist;

  swap_action_list_t( player_t* player, util::string_view options_str,
    util::string_view name = "swap_action_list" );

  void execute() override;
  bool ready() override;
};

struct run_action_list_t : public swap_action_list_t
{
  run_action_list_t( player_t* player, util::string_view options_str );

  void execute() override;
};