39 #define ERR_CF LOG_STREAM(err, log_config)
40 #define WRN_CF LOG_STREAM(warn, log_config)
41 #define LOG_CONFIG LOG_STREAM(info, log_config)
42 #define DBG_CF LOG_STREAM(debug, log_config)
45 #define DBG_UT LOG_STREAM(debug, log_unit)
46 #define ERR_UT LOG_STREAM(err, log_unit)
49 #define ERR_WML LOG_STREAM(err, log_wml)
55 , other_attack_(nullptr)
56 , description_(
cfg[
"description"].t_str())
60 , range_(
cfg[
"range"])
61 , min_range_(
cfg[
"min_range"].to_int(1))
62 , max_range_(
cfg[
"max_range"].to_int(1))
64 , damage_(
cfg[
"damage"].to_int())
65 , num_attacks_(
cfg[
"number"].to_int())
66 , attack_weight_(
cfg[
"attack_weight"].to_double(1.0))
67 , defense_weight_(
cfg[
"defense_weight"].to_double(1.0))
68 , accuracy_(
cfg[
"accuracy"].to_int())
69 , movement_used_(
cfg[
"movement_used"].to_int(100000))
70 , attacks_used_(
cfg[
"attacks_used"].to_int(1))
71 , parry_(
cfg[
"parry"].to_int())
72 , specials_(
cfg.child_or_empty(
"specials"))
82 icon_ =
"attacks/blank-attack.png";
126 const std::string& filter_min_range =
filter[
"min_range"];
127 const std::string& filter_max_range =
filter[
"max_range"];
128 const std::string& filter_damage =
filter[
"damage"];
129 const std::string& filter_attacks =
filter[
"number"];
130 const std::string& filter_accuracy =
filter[
"accuracy"];
131 const std::string& filter_parry =
filter[
"parry"];
132 const std::string& filter_movement =
filter[
"movement_used"];
133 const std::string& filter_attacks_used =
filter[
"attacks_used"];
138 const std::string filter_formula =
filter[
"formula"];
146 if ( !filter_range.empty() && filter_range.count(attack.
range()) == 0 )
167 if(!filter_alignment.empty() && filter_alignment.count(attack.
alignment_str()) == 0)
170 if ( !filter_name.empty() && filter_name.count(attack.
id()) == 0)
173 if (!filter_type.empty()){
178 if(check_if_recursion ==
"damage_type"){
179 if (filter_type.count(attack.
type()) == 0){
190 if ( !filter_base_type.empty() && filter_base_type.count(attack.
type()) == 0 )
193 if(
filter.has_attribute(
"special")) {
197 if(
filter.has_attribute(
"special") ||
filter.has_attribute(
"special_id") ||
filter.has_attribute(
"special_type")) {
203 if(
filter.has_attribute(
"special_active")) {
207 if(
filter.has_attribute(
"special_active") ||
filter.has_attribute(
"special_id_active") ||
filter.has_attribute(
"special_type_active")) {
215 if(
auto sub_filter_special =
filter.optional_child(
"filter_special")) {
221 if (!filter_formula.empty()) {
230 lg::log_to_chat() <<
"Formula error in weapon filter: " <<
e.type <<
" at " <<
e.filename <<
':' <<
e.line <<
")\n";
231 ERR_WML <<
"Formula error in weapon filter: " <<
e.type <<
" at " <<
e.filename <<
':' <<
e.line <<
")";
250 for(
const auto [key, condition_cfg] :
filter.all_children_view() )
254 matches = matches &&
matches_filter(condition_cfg, check_if_recursion);
257 else if ( key ==
"or" )
258 matches = matches ||
matches_filter(condition_cfg, check_if_recursion);
261 else if ( key ==
"not" )
262 matches = matches && !
matches_filter(condition_cfg, check_if_recursion);
298 const std::string& del_specials =
cfg[
"remove_specials"];
300 const std::string& increase_min_range =
cfg[
"increase_min_range"];
302 const std::string& increase_max_range =
cfg[
"increase_max_range"];
305 const std::string& increase_damage =
cfg[
"increase_damage"];
307 const std::string& increase_attacks =
cfg[
"increase_attacks"];
308 const std::string& set_attacks =
cfg[
"set_attacks"];
311 const std::string& increase_accuracy =
cfg[
"increase_accuracy"];
313 const std::string& increase_parry =
cfg[
"increase_parry"];
315 const std::string& increase_movement =
cfg[
"increase_movement_used"];
316 const std::string& set_movement =
cfg[
"set_movement_used"];
317 const std::string& increase_attacks_used =
cfg[
"increase_attacks_used"];
326 if(set_desc.
empty() ==
false) {
346 if(del_specials.empty() ==
false) {
347 const std::vector<std::string>& dsl =
utils::split(del_specials);
350 std::vector<std::string>::const_iterator found_id =
352 if (found_id == dsl.end()) {
363 "The mode defaults to 'replace', but should often be 'append' instead. The default may change in a future version, or the attribute may become mandatory.");
366 if(mode !=
"append") {
378 if(increase_min_range.empty() ==
false) {
386 if(increase_max_range.empty() ==
false) {
390 if(remove_specials) {
401 if(increase_damage.empty() ==
false) {
408 if(set_attacks.empty() ==
false) {
416 if(increase_attacks.empty() ==
false) {
424 if(increase_accuracy.empty() ==
false) {
432 if(increase_parry.empty() ==
false) {
436 if(set_movement.empty() ==
false) {
440 if(increase_movement.empty() ==
false) {
448 if(increase_attacks_used.empty() ==
false) {
480 if(description !=
nullptr) {
481 const std::string& increase_min_range =
cfg[
"increase_min_range"];
483 const std::string& increase_max_range =
cfg[
"increase_max_range"];
485 const std::string& increase_damage =
cfg[
"increase_damage"];
487 const std::string& increase_attacks =
cfg[
"increase_attacks"];
488 const std::string& set_attacks =
cfg[
"set_attacks"];
489 const std::string& increase_accuracy =
cfg[
"increase_accuracy"];
491 const std::string& increase_parry =
cfg[
"increase_parry"];
493 const std::string& increase_movement =
cfg[
"increase_movement_used"];
494 const std::string& set_movement =
cfg[
"set_movement_used"];
495 const std::string& increase_attacks_used =
cfg[
"increase_attacks_used"];
498 std::vector<t_string> desc;
507 if(!increase_min_range.empty()) {
510 "<span color=\"$color\">$number_or_percent</span> min range",
511 {{
"number_or_percent",
utils::print_modifier(increase_min_range)}, {
"color", increase_min_range[0] ==
'-' ?
"#f00" :
"#0f0"}}));
521 if(!increase_max_range.empty()) {
524 "<span color=\"$color\">$number_or_percent</span> max range",
525 {{
"number_or_percent",
utils::print_modifier(increase_max_range)}, {
"color", increase_max_range[0] ==
'-' ?
"#f00" :
"#0f0"}}));
528 if(!increase_damage.empty()) {
531 "<span color=\"$color\">$number_or_percent</span> damage",
532 "<span color=\"$color\">$number_or_percent</span> damage",
534 {{
"number_or_percent",
utils::print_modifier(increase_damage)}, {
"color", increase_damage[0] ==
'-' ?
"#f00" :
"#0f0"}}));
546 if(!increase_attacks.empty()) {
549 "<span color=\"$color\">$number_or_percent</span> strike",
550 "<span color=\"$color\">$number_or_percent</span> strikes",
552 {{
"number_or_percent",
utils::print_modifier(increase_attacks)}, {
"color", increase_attacks[0] ==
'-' ?
"#f00" :
"#0f0"}}));
555 if(!set_attacks.empty()) {
561 {{
"number", set_attacks}}));
571 if(!increase_accuracy.empty()) {
574 "<span color=\"$color\">$number_or_percent|%</span> accuracy",
575 {{
"number_or_percent",
utils::print_modifier(increase_accuracy)}, {
"color", increase_accuracy[0] ==
'-' ?
"#f00" :
"#0f0"}}));
585 if(!increase_parry.empty()) {
588 "<span color=\"$color\">$number_or_percent</span> parry",
589 {{
"number_or_percent",
utils::print_modifier(increase_parry)}, {
"color", increase_parry[0] ==
'-' ?
"#f00" :
"#0f0"}}));
592 if(!set_movement.empty()) {
595 "$number movement point",
596 "$number movement points",
598 {{
"number", set_movement}}));
601 if(!increase_movement.empty()) {
604 "<span color=\"$color\">$number_or_percent</span> movement point",
605 "<span color=\"$color\">$number_or_percent</span> movement points",
607 {{
"number_or_percent",
utils::print_modifier(increase_movement)}, {
"color", increase_movement[0] ==
'-' ?
"#f00" :
"#0f0"}}));
613 "$number attack used",
614 "$number attacks used",
619 if(!increase_attacks_used.empty()) {
622 "<span color=\"$color\">$number_or_percent</span> attack used",
623 "<span color=\"$color\">$number_or_percent</span> attacks used",
625 {{
"number_or_percent",
utils::print_modifier(increase_attacks_used)}, {
"color", increase_attacks_used[0] ==
'-' ?
"#f00" :
"#0f0"}}));
645 : parent(weapon.shared_from_this())
647 parent->open_queries_.emplace_back(&special);
655 attack_type::recursion_guard::operator bool()
const {
664 assert(
this != &other);
675 assert(!parent->open_queries_.empty());
676 parent->open_queries_.pop_back();
static lg::log_domain log_unit("unit")
static lg::log_domain log_wml("wml")
static bool matches_simple_filter(const attack_type &attack, const config &filter, const std::string &check_if_recursion)
Returns whether or not *this matches the given filter, ignoring the complexities introduced by [and],...
static lg::log_domain log_config("config")
Helper similar to std::unique_lock for detecting when calculations such as has_special have entered i...
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
std::string alignment_str() const
Returns alignment specified by alignment() for filtering when exist.
void set_min_range(int value)
const std::string & range() const
void set_attacks_used(int value)
int movement_used() const
bool has_special_or_ability_with_filter(const config &filter) const
check if special matche
void set_accuracy(int value)
const std::string & type() const
std::string accuracy_parry_tooltip() const
std::string accuracy_parry_description() const
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.
void set_specials(config value)
void set_defense_weight(double value)
void set_changed(bool value)
recursion_guard update_variables_recursion(const config &special) const
Tests which might otherwise cause infinite recursion should call this, check that the returned object...
bool has_filter_special_or_ability(const config &filter, bool simple_check=false) const
check if special matche
void set_parry(int value)
void set_attack_weight(double value)
void set_damage(int value)
bool describe_modification(const config &cfg, std::string *description)
Trimmed down version of apply_modification(), with no modifications actually made.
const std::string & id() const
void set_icon(const std::string &value)
std::vector< const config * > open_queries_
While processing a recursive match, all the filters that are currently being checked,...
bool special_matches_filter(const config &cfg, const std::string &tag_name, const config &filter) const
Filter a list of abilities or weapon specials.
void remove_special_by_filter(const config &filter)
remove special if matche condition
void set_max_range(int value)
utils::optional< unit_alignments::type > alignment_
attack_type(const config &cfg)
void set_type(const std::string &value)
void write(config &cfg) const
void set_range(const std::string &value)
void set_attack_alignment(const std::string &value)
void set_name(const t_string &value)
std::pair< std::string, int > effective_damage_type() const
The type of attack used and the resistance value that does the most damage.
A config object defines a single node in a WML file, with access to child nodes.
all_children_iterator erase(const all_children_iterator &i)
const_all_children_iterator ordered_begin() const
auto all_children_view() const
In-order iteration over all children.
const_all_children_iterator ordered_end() const
optional_config_impl< config > optional_child(config_key_type key, int n=0)
Equivalent to mandatory_child, but returns an empty optional if the nth child was not found.
config & add_child(config_key_type key)
bool as_bool() const
Returns a boolean state of the variant value.
void swap(config &lhs, config &rhs)
Implement non-member swap function for std::swap (calls config::swap).
std::string deprecated_message(const std::string &elem_name, DEP_LEVEL level, const version_info &version, const std::string &detail)
Interfaces for manipulating version numbers of engine, add-ons, etc.
static std::string _(const char *str)
std::string tooltip
Shown when hovering over an entry in the filter's drop-down list.
New lexcical_cast header.
Standard logging facilities (interface).
General math utility functions.
bool in_ranges(const Cmp c, const std::vector< std::pair< Cmp, Cmp >> &ranges)
std::stringstream & log_to_chat()
Use this to show WML errors in the ingame chat.
std::string bold(Args &&... data)
Applies bold Pango markup to the input.
std::string egettext(char const *msgid)
std::set< std::string > split_set(std::string_view s, char sep, const int flags)
int stoi(std::string_view str)
Same interface as std::stoi and meant as a drop in replacement, except:
std::vector< std::pair< int, int > > parse_ranges_int(const std::string &str)
Handles a comma-separated list of inputs to parse_range.
bool contains(const Container &container, const Value &value)
Returns true iff value is found in container.
std::vector< std::pair< int, int > > parse_ranges_unsigned(const std::string &str)
Handles a comma-separated list of inputs to parse_range, in a context that does not expect negative v...
int apply_modifier(const int number, const std::string &amount, const int minimum)
std::string format_conjunct_list(const t_string &empty, const std::vector< t_string > &elems)
Format a conjunctive list.
std::string signed_percent(int val)
Convert into a percentage (using the Unicode "−" and +0% convention.
std::vector< std::string > split(const config_attribute_value &val)
auto * find(Container &container, const Value &value)
Convenience wrapper for using find on a container without needing to comare to end()
std::string print_modifier(const std::string &mod)
Add a "+" or replace the "-" par Unicode minus.
The base template for associating string values with enum values.
static constexpr utils::optional< enum_type > get_enum(const std::string_view value)
Converts a string into its enum equivalent.
static map_location::direction s