pet_spawner.hpp

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

#include "config.hpp"
#include "spawner_base.hpp"
#include "player/player.hpp"

namespace spawner
{
enum pet_spawn_type
{
  PET_SPAWN_DYNAMIC,      
  PET_SPAWN_PERSISTENT    
};

enum pet_replacement_strategy
{
  NO_REPLACE,            
  REPLACE_OLDEST,        
  REPLACE_RANDOM,        
};

template<typename T, typename O = player_t>
class pet_spawner_t : public base_actor_spawner_t
{
public:
  using create_fn_t = std::function<T*(O*)>;
  using apply_fn_t = std::function<void(T*)>;
  using check_arg_fn_t = std::function<bool(const T*)>;
  using check_fn_t = std::function<bool(void)>;
  using expr_fn_t = std::function<std::unique_ptr<expr_t>(util::span<const util::string_view>)>;

private:
  // Creation phase determines what components of the init process are run on the created pet
  enum create_phase
  {
    PHASE_COMBAT,       
    PHASE_MERGE,        
    PHASE_INIT          
  };

  unsigned        m_max_pets;
  create_fn_t     m_creator;
  check_fn_t      m_check_create;
  std::vector<T*> m_pets, m_active_pets, m_inactive_pets;
  timespan_t      m_duration;
  pet_spawn_type  m_type;
  pet_replacement_strategy m_replacement_strategy;

  // Callbacks

  std::vector<apply_fn_t> m_event_create;

  // Expressions
  std::unordered_map<std::string, expr_fn_t> m_expressions;

  // Iteration uptime calculation
  timespan_t m_cumulative_uptime;
  timespan_t m_spawn_time;

  // Bookkeeping optimization

  bool m_dirty;
  size_t m_active;
  T* m_initial_pet;

  // Internal helper methods

  T* create_pet( create_phase phase );

  void update_state();

  T* replacement_pet();
public:
  pet_spawner_t( util::string_view id, O* p, pet_spawn_type st = PET_SPAWN_DYNAMIC );
  pet_spawner_t( util::string_view id, O* p, unsigned max_pets,
                   pet_spawn_type st = PET_SPAWN_DYNAMIC );
  pet_spawner_t( util::string_view id, O* p, unsigned max_pets, const create_fn_t& creator,
                   pet_spawn_type st = PET_SPAWN_DYNAMIC );
  pet_spawner_t( util::string_view id, O* p, const create_fn_t& creator,
                   pet_spawn_type st = PET_SPAWN_DYNAMIC );

  std::vector<T*> spawn( timespan_t duration = timespan_t::min(), unsigned n = 0 );
  std::vector<T*> spawn( unsigned n );
  size_t despawn();
  bool despawn( T* obj );
  size_t despawn( const std::vector<T*>& obj );
  size_t despawn( const check_arg_fn_t& fn );

  void extend_expiration( timespan_t adjustment );

  size_t n_active_pets() const;
  size_t n_active_pets( const check_arg_fn_t& fn );
  size_t n_inactive_pets() const;
  size_t n_pets() const;
  size_t max_pets() const;
  timespan_t duration() const;

  // Iteration
  typename std::vector<T*>::iterator begin();
  typename std::vector<T*>::iterator end();
  typename std::vector<T*>::const_iterator cbegin();
  typename std::vector<T*>::const_iterator cend();

  pet_spawner_t<T, O>& set_max_pets( unsigned v );
  pet_spawner_t<T, O>& set_creation_callback( const create_fn_t& fn );
  pet_spawner_t<T, O>& set_creation_check_callback( const check_fn_t& fn );
  pet_spawner_t<T, O>& set_creation_event_callback( const apply_fn_t& fn );
  pet_spawner_t<T, O>& set_default_duration( const spell_data_t* spell );
  pet_spawner_t<T, O>& set_default_duration( const spell_data_t& spell );
  pet_spawner_t<T, O>& set_default_duration( timespan_t duration );
  pet_spawner_t<T, O>& add_expression( const std::string& name, const expr_fn_t& fn );

  pet_spawner_t<T, O>&  set_replacement_strategy( pet_replacement_strategy new_ );

  // Access

  std::vector<T*> pets();
  std::vector<const T*> pets() const;
  std::vector<T*> active_pets();
  T* pet( size_t index = 0 ) const;
  T* active_pet( size_t index = 0 );
  T* active_pet( const check_arg_fn_t& fn );
  T* active_pet_max_remains( const check_arg_fn_t& fn = check_arg_fn_t() );
  T* active_pet_min_remains( const check_arg_fn_t& fn = check_arg_fn_t() );

  // Pure virtual implementations

  void merge( base_actor_spawner_t* other ) override;

  void create_persistent_actors() override;

  std::unique_ptr<expr_t> create_expression( util::span<const util::string_view> expr, util::string_view full_expression_str ) override;

  timespan_t iteration_uptime() const override;

  void reset() override;

  void datacollection_end() override;
};
} // Namespace spawner ends

#include "pet_spawner_impl.hpp"

#endif /* PET_SPAWNER_HPP */