dbc_proc_callback.hpp

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

#pragma once

#include "config.hpp"
#include "action_callback.hpp"

#include <functional>

struct action_state_t;
struct buff_t;
struct cooldown_t;
struct target_specific_cooldown_t;
struct item_t;
struct real_ppm_t;
namespace rng {
  struct rng_t;
}
struct special_effect_t;
struct weapon_t;
struct proc_event_t;

struct dbc_proc_callback_t : public action_callback_t
{
  // Additional trigger callbacks, currently used to control
  // the triggering conditions of the proc.
  enum class trigger_fn_type
  {
    NONE,
    CONDITION,
    TRIGGER
  };

  using execute_fn_t = std::function<void(const dbc_proc_callback_t*, action_t*, action_state_t*)>;
  using trigger_fn_t = std::function<bool(const dbc_proc_callback_t*, action_t*, action_state_t*)>;

  static const item_t default_item_;

  const item_t& item;
  const special_effect_t& effect;
  cooldown_t* cooldown;
  target_specific_cooldown_t* target_specific_cooldown;

  // Proc trigger types, cached/initialized here from special_effect_t to avoid
  // needless spell data lookups in vast majority of cases
  real_ppm_t* rppm;
  double      proc_chance;
  double      ppm;

  buff_t* proc_buff;
  action_t* proc_action;
  weapon_t* weapon;

  bool expire_on_max_stack;

  trigger_fn_type trigger_type;
  const trigger_fn_t* trigger_fn;
  execute_fn_t* execute_fn;

  bool can_only_proc_from_class_abilites;
  bool can_proc_from_procs;

  dbc_proc_callback_t(const item_t& i, const special_effect_t& e);

  dbc_proc_callback_t(const item_t* i, const special_effect_t& e);

  dbc_proc_callback_t(player_t* p, const special_effect_t& e);

  void initialize() override;

  cooldown_t* get_cooldown( player_t* target );

  void trigger(action_t* a, action_state_t* state) override;

  // Determine target for the callback (action).
  virtual player_t* target(const action_state_t* state) const;

  rng::rng_t& rng() const;

private:
  bool roll(action_t* action);

protected:
  friend struct proc_event_t;
  virtual void execute(action_t* /* a */, action_state_t* state);
};