The Battle for Wesnoth  1.19.13+dev
attack_type.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2025
3  by David White <dave@whitevine.net>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 #pragma once
17 
18 #include "map/location.hpp"
19 #include "tstring.hpp"
20 #include "config.hpp"
21 #include <string>
22 #include <vector>
23 
24 #include <boost/iterator/indirect_iterator.hpp>
25 #include <boost/dynamic_bitset_fwd.hpp>
26 
27 #include "units/ptr.hpp" // for attack_ptr
29 
30 class unit_ability_list;
31 class unit_type;
32 namespace wfl {
33  class map_formula_callable;
34 }
35 //the 'attack type' is the type of attack, how many times it strikes,
36 //and how much damage it does.
37 class attack_type : public std::enable_shared_from_this<attack_type>
38 {
39 public:
40 
41  explicit attack_type(const config& cfg);
42  const t_string& name() const { return description_; }
43  const std::string& id() const { return id_; }
44  const std::string& type() const { return type_; }
45  const std::string& icon() const { return icon_; }
46  const std::string& range() const { return range_; }
47  int min_range() const { return min_range_; }
48  int max_range() const { return max_range_; }
49  std::string accuracy_parry_description() const;
50  std::string accuracy_parry_tooltip() const;
51  int accuracy() const { return accuracy_; }
52  int parry() const { return parry_; }
53  int damage() const { return damage_; }
54  int num_attacks() const { return num_attacks_; }
55  double attack_weight() const { return attack_weight_; }
56  double defense_weight() const { return defense_weight_; }
57  const config &specials() const { return specials_; }
58 
59  void set_name(const t_string& value) { description_ = value; set_changed(true); }
60  void set_id(const std::string& value) { id_ = value; set_changed(true); }
61  void set_type(const std::string& value) { type_ = value; set_changed(true); }
62  void set_icon(const std::string& value) { icon_ = value; set_changed(true); }
63  void set_range(const std::string& value) { range_ = value; set_changed(true); }
64  void set_min_range(int value) { min_range_ = value; set_changed(true); }
65  void set_max_range(int value) { max_range_ = value; set_changed(true); }
66  void set_attack_alignment(const std::string& value) { alignment_ = unit_alignments::get_enum(value); set_changed(true); }
67  void set_accuracy(int value) { accuracy_ = value; set_changed(true); }
68  void set_parry(int value) { parry_ = value; set_changed(true); }
69  void set_damage(int value) { damage_ = value; set_changed(true); }
70  void set_num_attacks(int value) { num_attacks_ = value; set_changed(true); }
71  void set_attack_weight(double value) { attack_weight_ = value; set_changed(true); }
72  void set_defense_weight(double value) { defense_weight_ = value; set_changed(true); }
73  void set_specials(config value) { specials_ = value; set_changed(true); }
74 
75 
76  // In unit_abilities.cpp:
77 
78  /**
79  * @return True iff the special @a special is active.
80  * @param special The special being checked.
81  * @param simple_check If true, check whether the unit has the special. Else, check whether the special is currently active.
82  */
83  bool has_special(const std::string& special, bool simple_check = false) const;
84  unit_ability_list get_specials(const std::string& special) const;
85  std::vector<std::pair<t_string, t_string>> special_tooltips(boost::dynamic_bitset<>* active_list = nullptr) const;
86  std::vector<std::pair<t_string, t_string>> abilities_special_tooltips(boost::dynamic_bitset<>* active_list = nullptr) const;
87  std::string weapon_specials() const;
88  std::string weapon_specials_value(const std::set<std::string>& checking_tags) const;
89 
90  /** Returns alignment specified by alignment_ variable.
91  */
92  utils::optional<unit_alignments::type> alignment() const { return alignment_; }
93  /** Returns alignment specified by alignment() for filtering when exist.
94  */
95  std::string alignment_str() const { return alignment_ ? unit_alignments::get_string(*alignment_) : ""; }
96 
97  /** Calculates the number of attacks this weapon has, considering specials. */
98  void modified_attacks(unsigned & min_attacks,
99  unsigned & max_attacks) const;
100 
101  /** @return A type()/replacement_type and a list of alternative_types that should be displayed in the selected unit's report. */
102  std::pair<std::string, std::set<std::string>> damage_types() const;
103  /** @return The type of attack used and the resistance value that does the most damage. */
104  std::pair<std::string, int> effective_damage_type() const;
105 
106  /** Returns the damage per attack of this weapon, considering specials. */
107  double modified_damage() const;
108 
109  /** Return the special weapon value, considering specials.
110  * @param abil_list The list of special checked.
111  * @param base_value The value modified or not by function.
112  */
113  int composite_value(const unit_ability_list& abil_list, int base_value) const;
114  /** Returns list for weapon like abilities for each ability type. */
115  unit_ability_list get_weapon_ability(const std::string& ability) const;
116  /**
117  * @param special the tag name to check for
118  * @return list which contains get_weapon_ability and get_specials list for each ability type, with overwritten items removed
119  */
120  unit_ability_list get_specials_and_abilities(const std::string& special) const;
121  /** used for abilities used like weapon and true specials
122  * @return True if the ability @a special is active.
123  * @param special The special being checked.
124  */
125  bool has_special_or_ability(const std::string& special) const;
126  /** check if special matche
127  * @return True if special matche with filter(if 'active' filter is true, check if special active).
128  * @param simple_check If true, check whether the unit has the special. Else, check whether the special is currently active.
129  * @param filter contain attributes to check(special_id, special_type etc...).
130  */
131  bool has_filter_special_or_ability(const config& filter, bool simple_check = false) const;
132  /**
133  * Returns true if this is a dummy attack_type, for example the placeholder that the unit_attack dialog
134  * uses when a defender has no weapon for a given range.
135  */
136  bool attack_empty() const {return (id().empty() && name().empty() && type().empty() && range().empty());}
137  /** remove special if matche condition
138  * @param filter if special check with filter, it will be removed.
139  */
141  /** check if special matche
142  * @return True if special matche with filter(if 'active' filter is true, check if special active).
143  * @param filter if special check with filter, return true.
144  */
146 
147  // In unit_types.cpp:
148 
149  bool matches_filter(const config& filter, const std::string& check_if_recursion = "") const;
150  bool apply_modification(const config& cfg);
151  bool describe_modification(const config& cfg,std::string* description);
152 
153  int movement_used() const { return movement_used_; }
154  void set_movement_used(int value) { movement_used_ = value; }
155  int attacks_used() const { return attacks_used_; }
156  void set_attacks_used(int value) { attacks_used_ = value; }
157 
158  void write(config& cfg) const;
159  inline config to_config() const { config c; write(c); return c; }
160 
162 
163  /**
164  * Helper similar to std::unique_lock for detecting when calculations such as has_special
165  * have entered infinite recursion.
166  *
167  * This assumes that there's only a single thread accessing the attack_type, it's a lightweight
168  * increment/decrement counter rather than a mutex.
169  */
171  friend class attack_type;
172  /**
173  * Only expected to be called in update_variables_recursion(), which handles some of the checks.
174  */
175  explicit recursion_guard(const attack_type& weapon, const config& special);
176  public:
177  /**
178  * Construct an empty instance, only useful for extending the lifetime of a
179  * recursion_guard returned from weapon.update_variables_recursion() by
180  * std::moving it to an instance declared in a larger scope.
181  */
182  explicit recursion_guard();
183 
184  /**
185  * Returns true if a level of recursion was available at the time when update_variables_recursion()
186  * created this object.
187  */
188  operator bool() const;
189 
190  recursion_guard(recursion_guard&& other) noexcept;
191  recursion_guard(const recursion_guard& other) = delete;
193  recursion_guard& operator=(const recursion_guard&) = delete;
194  ~recursion_guard();
195  private:
196  std::shared_ptr<const attack_type> parent;
197  };
198 
199  /**
200  * Tests which might otherwise cause infinite recursion should call this, check that the
201  * returned object evaluates to true, and then keep the object returned as long as the
202  * recursion might occur, similar to a reentrant mutex that's limited to a small number of
203  * reentrances.
204  *
205  * This only expects to be called in a single thread, but the whole of attack_type makes
206  * that assumption, for example its' mutable members are assumed to be set up by the current
207  * caller (or caller's caller, probably several layers up).
208  */
209  recursion_guard update_variables_recursion(const config& special) const;
210 
211 private:
212  // In unit_abilities.cpp:
213 
214  // Configured as a bit field, in case that is useful.
216  /**
217  * Filter a list of abilities or weapon specials
218  * @param cfg config of ability checked
219  * @param tag_name le type of ability who is checked
220  * @param filter config contain list of attribute who are researched in cfg
221  *
222  * @return true if all attribute with ability checked
223  */
224  bool special_matches_filter(const config & cfg, const std::string& tag_name, const config & filter) const;
225  /**
226  * Select best damage type based on frequency count for replacement_type.
227  *
228  * @param damage_type_list list of [damage_type] to check.
229  */
230  std::string select_replacement_type(const unit_ability_list& damage_type_list) const;
231  /**
232  * Select best damage type based on highest damage for alternative_type.
233  *
234  * @param damage_type_list list of [damage_type] to check.
235  * @param resistance_list list of "resistance" abilities to check for each type of damage checked.
236  */
237  std::pair<std::string, int> select_alternative_type(const unit_ability_list& damage_type_list, const unit_ability_list& resistance_list) const;
238  /**
239  * Filter a list of abilities or weapon specials, removing any entries that don't own
240  * the overwrite_specials attributes.
241  *
242  * @param overwriters list that may have overwrite_specials attributes.
243  * @param tag_name type of abilitie/special checked.
244  */
245  unit_ability_list overwrite_special_overwriter(unit_ability_list overwriters, const std::string& tag_name) const;
246  /**
247  * Check whether @a cfg would be overwritten by any element of @a overwriters.
248  *
249  * @return True if element checked is overwritable.
250  * @param overwriters list used for check if element is overwritable.
251  * @param cfg element checked.
252  * @param tag_name type of abilitie/special checked.
253  */
254  bool overwrite_special_checking(unit_ability_list& overwriters, const config& cfg, const std::string& tag_name) const;
255  /** check_self_abilities : return an boolean value for checking of activities of abilities used like weapon
256  * @return True if the special @a special is active.
257  * @param cfg the config to one special ability checked.
258  * @param special The special ability type who is being checked.
259  */
260  bool check_self_abilities(const config& cfg, const std::string& special) const;
261  /** check_adj_abilities : return an boolean value for checking of activities of abilities used like weapon
262  * @return True if the special @a special is active.
263  * @param cfg the config to one special ability checked.
264  * @param special The special ability type who is being checked.
265  * @param dist distance between unit distant and self_.
266  * @param dir direction to research a unit distant to self_.
267  * @param from unit distant to self_ is checked.
268  * @param from_loc location of @a from
269  */
270  bool check_adj_abilities(const config& cfg, const std::string& special, std::size_t dist, int dir, const unit& from, const map_location& from_loc) const;
271  bool special_active(const config& special, AFFECTS whom, const std::string& tag_name,
272  bool in_abilities_tag = false) const;
273 
274 /** weapon_specials_impl_self and weapon_specials_impl_adj : check if special name can be added.
275  * @param[in,out] temp_string the string modified and returned
276  * @param[in] self the unit checked.
277  * @param[in] self_attack the attack used by unit checked in this function.
278  * @param[in] other_attack the attack used by opponent to unit checked.
279  * @param[in] self_loc location of the unit checked.
280  * @param[in] whom determine if unit affected or not by special ability.
281  * @param[in,out] checking_name the reference for checking if a name is already added
282  * @param[in] checking_tags the reference for checking if special ability type can be used
283  * @param[in] leader_bool If true, [leadership] abilities are checked.
284  */
285  static void weapon_specials_impl_self(
286  std::string& temp_string,
287  const unit_const_ptr& self,
288  const const_attack_ptr& self_attack,
289  const const_attack_ptr& other_attack,
290  const map_location& self_loc,
291  AFFECTS whom,
292  std::set<std::string>& checking_name,
293  const std::set<std::string>& checking_tags={},
294  bool leader_bool=false
295  );
296 
297  static void weapon_specials_impl_adj(
298  std::string& temp_string,
299  const unit_const_ptr& self,
300  const const_attack_ptr& self_attack,
301  const const_attack_ptr& other_attack,
302  const map_location& self_loc,
303  AFFECTS whom,
304  std::set<std::string>& checking_name,
305  const std::set<std::string>& checking_tags={},
306  const std::string& affect_adjacents="",
307  bool leader_bool=false
308  );
309  /** check_self_abilities_impl : return an boolean value for checking of activities of abilities used like weapon
310  * @return True if the special @a tag_name is active.
311  * @param self_attack the attack used by unit checked in this function.
312  * @param other_attack the attack used by opponent to unit checked.
313  * @param special the config to one special ability checked.
314  * @param u the unit checked.
315  * @param loc location of the unit checked.
316  * @param whom determine if unit affected or not by special ability.
317  * @param tag_name The special ability type who is being checked.
318  * @param leader_bool If true, [leadership] abilities are checked.
319  */
320  static bool check_self_abilities_impl(
321  const const_attack_ptr& self_attack,
322  const const_attack_ptr& other_attack,
323  const config& special,
324  const unit_const_ptr& u,
325  const map_location& loc,
326  AFFECTS whom,
327  const std::string& tag_name,
328  bool leader_bool=false
329  );
330 
331 
332  /** check_adj_abilities_impl : return an boolean value for checking of activities of abilities used like weapon in unit adjacent to fighter
333  * @return True if the special @a tag_name is active.
334  * @param self_attack the attack used by unit who fight.
335  * @param other_attack the attack used by opponent.
336  * @param special the config to one special ability checked.
337  * @param u the unit who is or not affected by an abilities owned by @a from.
338  * @param from unit distant to @a u is checked.
339  * @param dist distance between unit distant and @a u.
340  * @param dir direction to research a unit distant to @a u.
341  * @param loc location of the unit checked.
342  * @param from_loc location of the unit distant to @a u.
343  * @param whom determine if unit affected or not by special ability.
344  * @param tag_name The special ability type who is being checked.
345  * @param leader_bool If true, [leadership] abilities are checked.
346  */
347  static bool check_adj_abilities_impl(
348  const const_attack_ptr& self_attack,
349  const const_attack_ptr& other_attack,
350  const config& special,
351  const unit_const_ptr& u,
352  const unit& from,
353  std::size_t dist,
354  int dir,
355  const map_location& loc,
356  const map_location& from_loc,
357  AFFECTS whom,
358  const std::string& tag_name,
359  bool leader_bool = false
360  );
361 
362  static bool special_active_impl(
363  const const_attack_ptr& self_attack,
364  const const_attack_ptr& other_attack,
365  const config& special,
366  AFFECTS whom,
367  const std::string& tag_name,
368  bool in_abilities_tag = false
369  );
370 
371  // Used via specials_context() to control which specials are
372  // considered active.
373  friend class specials_context_t;
377  mutable bool is_attacker_;
379  mutable bool is_for_listing_ = false;
380 public:
382  std::shared_ptr<const attack_type> parent;
383  friend class attack_type;
384  /** Initialize weapon specials context for listing */
385  explicit specials_context_t(const attack_type& weapon, bool attacking);
386  /** Initialize weapon specials context for a unit type */
387  specials_context_t(const attack_type& weapon, const unit_type& self_type, const map_location& loc, bool attacking = true);
388  /** Initialize weapon specials context for a single unit */
389  specials_context_t(const attack_type& weapon, const_attack_ptr other_weapon,
390  unit_const_ptr self, unit_const_ptr other,
391  const map_location& self_loc, const map_location& other_loc,
392  bool attacking);
393  /** Initialize weapon specials context for a pair of units */
394  specials_context_t(const attack_type& weapon, unit_const_ptr self, const map_location& loc, bool attacking);
396  bool was_moved = false;
397  public:
398  // Destructor at least needs to be public for all this to work.
401  };
402  // Set up a specials context.
403  // Usage: auto ctx = weapon.specials_context(...);
405  const map_location& unit_loc, const map_location& other_loc,
406  bool attacking, const_attack_ptr other_attack) const {
407  return specials_context_t(*this, other_attack, self, other, unit_loc, other_loc, attacking);
408  }
409  specials_context_t specials_context(unit_const_ptr self, const map_location& loc, bool attacking = true) const {
410  return specials_context_t(*this, self, loc, attacking);
411  }
412  specials_context_t specials_context(const unit_type& self_type, const map_location& loc, bool attacking = true) const {
413  return specials_context_t(*this, self_type, loc, attacking);
414  }
415  specials_context_t specials_context_for_listing(bool attacking = true) const {
416  return specials_context_t(*this, attacking);
417  }
418  void set_changed(bool value)
419  {
420  changed_ = value;
421  }
422  bool get_changed() const
423  {
424  return changed_;
425  }
426 private:
427 
429  std::string id_;
430  std::string type_;
431  std::string icon_;
432  std::string range_;
434  utils::optional<unit_alignments::type> alignment_;
435  int damage_;
439 
443  int parry_;
445  bool changed_;
446  /**
447  * While processing a recursive match, all the filters that are currently being checked, oldest first.
448  * Each will have an instance of recursion_guard that is currently allocated permission to recurse, and
449  * which will pop the config off this stack when the recursion_guard is finalized.
450  */
451  mutable std::vector<const config*> open_queries_;
452 };
453 
454 using attack_list = std::vector<attack_ptr>;
455 using attack_itors = boost::iterator_range<boost::indirect_iterator<attack_list::iterator>>;
456 using const_attack_itors = boost::iterator_range<boost::indirect_iterator<attack_list::const_iterator>>;
457 
459  return boost::make_iterator_range(boost::make_indirect_iterator(atks.begin()), boost::make_indirect_iterator(atks.end()));
460 }
461 
463  return boost::make_iterator_range(boost::make_indirect_iterator(atks.begin()), boost::make_indirect_iterator(atks.end()));
464 }
map_location loc
Definition: move.cpp:172
boost::iterator_range< boost::indirect_iterator< attack_list::iterator > > attack_itors
std::vector< attack_ptr > attack_list
boost::iterator_range< boost::indirect_iterator< attack_list::const_iterator > > const_attack_itors
attack_itors make_attack_itors(attack_list &atks)
Helper similar to std::unique_lock for detecting when calculations such as has_special have entered i...
recursion_guard(const recursion_guard &other)=delete
std::shared_ptr< const attack_type > parent
recursion_guard()
Construct an empty instance, only useful for extending the lifetime of a recursion_guard returned fro...
recursion_guard & operator=(recursion_guard &&) noexcept
specials_context_t(const specials_context_t &)=delete
std::shared_ptr< const attack_type > parent
const config & specials() const
Definition: attack_type.hpp:57
std::string alignment_str() const
Returns alignment specified by alignment() for filtering when exist.
Definition: attack_type.hpp:95
bool special_active(const config &special, AFFECTS whom, const std::string &tag_name, bool in_abilities_tag=false) const
Definition: abilities.cpp:2239
void set_min_range(int value)
Definition: attack_type.hpp:64
map_location other_loc_
std::string weapon_specials() const
Returns a comma-separated string of active names for the specials of *this.
Definition: abilities.cpp:1004
double defense_weight() const
Definition: attack_type.hpp:56
void set_num_attacks(int value)
Definition: attack_type.hpp:70
specials_context_t specials_context(unit_const_ptr self, const map_location &loc, bool attacking=true) const
bool check_self_abilities(const config &cfg, const std::string &special) const
check_self_abilities : return an boolean value for checking of activities of abilities used like weap...
Definition: abilities.cpp:1729
int min_range() const
Definition: attack_type.hpp:47
std::string weapon_specials_value(const std::set< std::string > &checking_tags) const
Definition: abilities.cpp:1049
int composite_value(const unit_ability_list &abil_list, int base_value) const
Return the special weapon value, considering specials.
Definition: abilities.cpp:1594
double attack_weight() const
Definition: attack_type.hpp:55
const_attack_ptr other_attack_
void add_formula_context(wfl::map_formula_callable &) const
Definition: abilities.cpp:679
const std::string & range() const
Definition: attack_type.hpp:46
void set_attacks_used(int value)
map_location self_loc_
int movement_used() const
specials_context_t specials_context_for_listing(bool attacking=true) const
bool has_special_or_ability_with_filter(const config &filter) const
check if special matche
Definition: abilities.cpp:2147
void set_accuracy(int value)
Definition: attack_type.hpp:67
bool get_changed() const
const std::string & type() const
Definition: attack_type.hpp:44
void set_movement_used(int value)
std::string select_replacement_type(const unit_ability_list &damage_type_list) const
Select best damage type based on frequency count for replacement_type.
Definition: abilities.cpp:1268
bool has_special_or_ability(const std::string &special) const
used for abilities used like weapon and true specials
Definition: abilities.cpp:1775
unit_ability_list get_weapon_ability(const std::string &ability) const
Returns list for weapon like abilities for each ability type.
Definition: abilities.cpp:1558
int parry() const
Definition: attack_type.hpp:52
std::string accuracy_parry_tooltip() const
std::string accuracy_parry_description() const
Definition: attack_type.cpp:86
double modified_damage() const
Returns the damage per attack of this weapon, considering specials.
Definition: abilities.cpp:1382
unit_ability_list get_specials_and_abilities(const std::string &special) const
Definition: abilities.cpp:1577
bool apply_modification(const config &cfg)
Modifies *this using the specifications in cfg, but only if *this matches cfg viewed as a filter.
bool matches_filter(const config &filter, const std::string &check_if_recursion="") const
Returns whether or not *this matches the given filter.
static bool special_active_impl(const const_attack_ptr &self_attack, const const_attack_ptr &other_attack, const config &special, AFFECTS whom, const std::string &tag_name, bool in_abilities_tag=false)
Returns whether or not the given special is active for the specified unit, based on the current conte...
Definition: abilities.cpp:2255
bool overwrite_special_checking(unit_ability_list &overwriters, const config &cfg, const std::string &tag_name) const
Check whether cfg would be overwritten by any element of overwriters.
Definition: abilities.cpp:1641
void set_specials(config value)
Definition: attack_type.hpp:73
unit_const_ptr self_
friend class specials_context_t
config specials_
void set_defense_weight(double value)
Definition: attack_type.hpp:72
int num_attacks() const
Definition: attack_type.hpp:54
static void weapon_specials_impl_adj(std::string &temp_string, const unit_const_ptr &self, const const_attack_ptr &self_attack, const const_attack_ptr &other_attack, const map_location &self_loc, AFFECTS whom, std::set< std::string > &checking_name, const std::set< std::string > &checking_tags={}, const std::string &affect_adjacents="", bool leader_bool=false)
Definition: abilities.cpp:1109
void set_changed(bool value)
unit_ability_list overwrite_special_overwriter(unit_ability_list overwriters, const std::string &tag_name) const
Filter a list of abilities or weapon specials, removing any entries that don't own the overwrite_spec...
Definition: abilities.cpp:1605
recursion_guard update_variables_recursion(const config &special) const
Tests which might otherwise cause infinite recursion should call this, check that the returned object...
std::pair< std::string, int > select_alternative_type(const unit_ability_list &damage_type_list, const unit_ability_list &resistance_list) const
Select best damage type based on highest damage for alternative_type.
Definition: abilities.cpp:1297
std::vector< std::pair< t_string, t_string > > special_tooltips(boost::dynamic_bitset<> *active_list=nullptr) const
Returns a vector of names and descriptions for the specials of *this.
Definition: abilities.cpp:889
static void weapon_specials_impl_self(std::string &temp_string, const unit_const_ptr &self, const const_attack_ptr &self_attack, const const_attack_ptr &other_attack, const map_location &self_loc, AFFECTS whom, std::set< std::string > &checking_name, const std::set< std::string > &checking_tags={}, bool leader_bool=false)
weapon_specials_impl_self and weapon_specials_impl_adj : check if special name can be added.
Definition: abilities.cpp:1089
bool has_filter_special_or_ability(const config &filter, bool simple_check=false) const
check if special matche
Definition: abilities.cpp:1858
std::pair< std::string, std::set< std::string > > damage_types() const
Return a type()/replacement_type and a list of alternative_types that should be displayed in the sele...
Definition: abilities.cpp:1361
std::string type_
std::string icon_
void set_parry(int value)
Definition: attack_type.hpp:68
void set_attack_weight(double value)
Definition: attack_type.hpp:71
void set_damage(int value)
Definition: attack_type.hpp:69
utils::optional< unit_alignments::type > alignment() const
Returns alignment specified by alignment_ variable.
Definition: attack_type.hpp:92
const t_string & name() const
Definition: attack_type.hpp:42
bool describe_modification(const config &cfg, std::string *description)
Trimmed down version of apply_modification(), with no modifications actually made.
int attacks_used() const
const std::string & id() const
Definition: attack_type.hpp:43
void set_icon(const std::string &value)
Definition: attack_type.hpp:62
std::vector< std::pair< t_string, t_string > > abilities_special_tooltips(boost::dynamic_bitset<> *active_list=nullptr) const
Definition: abilities.cpp:925
std::vector< const config * > open_queries_
While processing a recursive match, all the filters that are currently being checked,...
static bool check_adj_abilities_impl(const const_attack_ptr &self_attack, const const_attack_ptr &other_attack, const config &special, const unit_const_ptr &u, const unit &from, std::size_t dist, int dir, const map_location &loc, const map_location &from_loc, AFFECTS whom, const std::string &tag_name, bool leader_bool=false)
check_adj_abilities_impl : return an boolean value for checking of activities of abilities used like ...
Definition: abilities.cpp:1754
static bool check_self_abilities_impl(const const_attack_ptr &self_attack, const const_attack_ptr &other_attack, const config &special, const unit_const_ptr &u, const map_location &loc, AFFECTS whom, const std::string &tag_name, bool leader_bool=false)
check_self_abilities_impl : return an boolean value for checking of activities of abilities used like...
Definition: abilities.cpp:1734
bool attack_empty() const
Returns true if this is a dummy attack_type, for example the placeholder that the unit_attack dialog ...
double defense_weight_
std::string id_
bool special_matches_filter(const config &cfg, const std::string &tag_name, const config &filter) const
Filter a list of abilities or weapon specials.
Definition: abilities.cpp:2142
double attack_weight_
config to_config() const
void modified_attacks(unsigned &min_attacks, unsigned &max_attacks) const
Calculates the number of attacks this weapon has, considering specials.
Definition: abilities.cpp:1247
std::string range_
void set_id(const std::string &value)
Definition: attack_type.hpp:60
void remove_special_by_filter(const config &filter)
remove special if matche condition
specials_context_t specials_context(unit_const_ptr self, unit_const_ptr other, const map_location &unit_loc, const map_location &other_loc, bool attacking, const_attack_ptr other_attack) const
void set_max_range(int value)
Definition: attack_type.hpp:65
utils::optional< unit_alignments::type > alignment_
attack_type(const config &cfg)
Definition: attack_type.cpp:51
void set_type(const std::string &value)
Definition: attack_type.hpp:61
void write(config &cfg) const
int accuracy() const
Definition: attack_type.hpp:51
unit_const_ptr other_
bool check_adj_abilities(const config &cfg, const std::string &special, std::size_t dist, int dir, const unit &from, const map_location &from_loc) const
check_adj_abilities : return an boolean value for checking of activities of abilities used like weapo...
Definition: abilities.cpp:1749
int max_range() const
Definition: attack_type.hpp:48
void set_range(const std::string &value)
Definition: attack_type.hpp:63
unit_ability_list get_specials(const std::string &special) const
Returns the currently active specials as an ability list, given the current context (see set_specials...
Definition: abilities.cpp:856
const std::string & icon() const
Definition: attack_type.hpp:45
specials_context_t specials_context(const unit_type &self_type, const map_location &loc, bool attacking=true) const
int damage() const
Definition: attack_type.hpp:53
void set_attack_alignment(const std::string &value)
Definition: attack_type.hpp:66
t_string description_
void set_name(const t_string &value)
Definition: attack_type.hpp:59
bool is_for_listing_
bool has_special(const std::string &special, bool simple_check=false) const
Returns whether or not *this has a special with a tag or id equal to special.
Definition: abilities.cpp:827
std::pair< std::string, int > effective_damage_type() const
The type of attack used and the resistance value that does the most damage.
Definition: abilities.cpp:1330
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:158
A single unit type that the player may recruit.
Definition: types.hpp:43
This class represents a single unit of a specific type.
Definition: unit.hpp:132
Definitions for the interface to Wesnoth Markup Language (WML).
const config * cfg
constexpr auto filter
Definition: ranges.hpp:38
Definition: callable.hpp:26
std::shared_ptr< const unit > unit_const_ptr
Definition: ptr.hpp:27
std::shared_ptr< const attack_type > const_attack_ptr
Definition: ptr.hpp:34
Encapsulates the map of the game.
Definition: location.hpp:45
static std::string get_string(enum_type key)
Converts a enum to its string equivalent.
Definition: enum_base.hpp:46
static constexpr utils::optional< enum_type > get_enum(const std::string_view value)
Converts a string into its enum equivalent.
Definition: enum_base.hpp:57
mock_char c