23 #include "formula/callable_objects.hpp"
34 #include <boost/range/algorithm_ext/erase.hpp>
40 #define ERR_CF LOG_STREAM(err, log_config)
41 #define WRN_CF LOG_STREAM(warn, log_config)
42 #define LOG_CONFIG LOG_STREAM(info, log_config)
43 #define DBG_CF LOG_STREAM(debug, log_config)
46 #define DBG_UT LOG_STREAM(debug, log_unit)
47 #define LOG_UT LOG_STREAM(info, log_unit)
48 #define ERR_UT LOG_STREAM(err, log_unit)
55 , id_(cfg.has_attribute(
"id") ? cfg[
"id"].str() : parent_id)
57 , parent_id_(!parent_id.empty() ? parent_id : id_)
62 , hp_bar_scaling_(0.0)
63 , xp_bar_scaling_(0.0)
81 , default_variation_()
90 , advancements_(cfg.child_range(
"advancement"))
91 , experience_needed_(0)
97 , build_status_(NOT_BUILT)
116 built_cfg_ = std::make_unique<config>(std::move(cfg));
125 , name(cfg[
"name"].t_str())
126 , name_inactive(cfg[
"name_inactive"].t_str())
127 , female_name(cfg[
"female_name"].t_str())
128 , female_name_inactive(cfg[
"female_name_inactive"].t_str())
129 , description(cfg[
"description"].t_str())
130 , description_inactive(cfg[
"description_inactive"].t_str())
131 , affect_self(cfg[
"affect_self"].to_bool())
132 , affect_allies(cfg[
"affect_allies"].to_bool())
133 , affect_enemies(cfg[
"affect_enemies"].to_bool())
134 , cumulative(cfg[
"cumulative"].to_bool())
152 for(
int i = 0;
i < 2; ++
i) {
172 for(variations_map::value_type& variation :
variations_) {
173 variation.second.build_full(mv_types, races, traits);
200 level_ = cfg[
"level"].to_int();
203 vision_ = cfg[
"vision"].to_int(-1);
204 jamming_ = cfg[
"jamming"].to_int(0);
206 usage_ = cfg[
"usage"].str();
209 icon_ = cfg[
"image_icon"].str();
223 for(
int i = 0;
i < 2; ++
i) {
230 pair.second.build_help_index(mv_types, races, traits);
233 const race_map::const_iterator race_it = races.find(cfg[
"race"]);
234 if(race_it != races.end()) {
235 race_ = &race_it->second;
253 for(
const auto [key, cfg] : abil_cfg->all_children_view()) {
267 auto abil_cfg = effect.optional_child(
"abilities");
269 if(!abil_cfg || effect[
"apply_to"] !=
"new_ability") {
273 for(
const auto [key, cfg] : abil_cfg->all_children_view()) {
280 const std::string move_type = cfg[
"movement_type"];
282 const movement_type_map::const_iterator find_it = mv_types.find(move_type);
284 if(find_it != mv_types.end()) {
285 DBG_UT <<
"inheriting from movement_type '" << move_type <<
"'";
287 }
else if(!move_type.empty()) {
288 DBG_UT <<
"movement_type '" << move_type <<
"' not found";
294 for(
const config&
t : traits) {
303 if(cfg[
"ignore_race_traits"].to_bool()) {
307 if(
alignment_ != unit_alignments::type::neutral ||
t[
"id"] !=
"fearless")
347 pair.second.build_created();
353 const std::string& advances_to_val = cfg[
"advances_to"];
354 if(advances_to_val !=
"null" && !advances_to_val.empty()) {
362 DBG_UT <<
"unit_type '" <<
log_id() <<
"' advances to : " << advances_to_val;
365 cost_ = cfg[
"cost"].to_int(1);
368 image_ = cfg[
"image"].str();
380 DBG_UT <<
"Building unit type " <<
log_id() <<
", level " << status;
403 ERR_UT <<
"Build of unit_type to unrecognized status (" << status <<
") requested.";
423 const std::size_t
i = gender;
433 const variations_map::const_iterator
i =
variations_.find(
id);
444 return (
_(
"No description available."));
455 if(new_note.
empty())
return;
456 std::string_view note_plain = new_note.
c_str();
458 if(note_plain.empty())
return;
459 auto iter =
std::find(notes.begin(), notes.end(), new_note);
460 if(iter != notes.end())
return;
461 notes.push_back(new_note);
466 std::vector<t_string> notes;
467 for(
const auto& note : direct) {
471 if(cfg.has_attribute(
"special_note")) {
475 for(
const auto& attack :
attacks) {
476 for(
const auto [key, cfg] : attack.specials().all_children_view()) {
477 if(cfg.has_attribute(
"special_note")) {
481 if(
auto attack_type_note =
string_table.find(
"special_note_damage_type_" + attack.type()); attack_type_note !=
string_table.end()) {
515 int experience_modifier = 100;
519 : old_value_(experience_modifier)
521 experience_modifier = modifier;
531 return experience_modifier;
536 if(with_acceleration) {
550 if(
auto abil =
get_cfg().optional_child(
"abilities")) {
551 for(
const auto [key, cfg] : abil->all_children_view()) {
552 if(cfg[
"id"] == ability) {
563 std::vector<std::string> res;
570 for(
const auto [key, cfg] : abilities->all_children_view()) {
571 std::string
id = cfg[
"id"];
574 res.push_back(std::move(
id));
595 if(tree.insert(adv).second) {
604 std::set<std::string> tree;
614 std::vector<std::string> adv_from;
615 for(
const unit_type_data::unit_type_map::value_type& ut :
unit_types.
types()) {
616 for(
const std::string& adv : ut.second.advances_to()) {
618 adv_from.push_back(ut.second.id());
632 bool current_status =
false;
639 if(mod[
"availability"] !=
"musthave") {
649 const std::string& ut = effect[
"unit_type"];
652 const std::vector<std::string>& types =
utils::split(ut);
654 if(
std::find(types.begin(), types.end(),
id()) == types.end()) {
660 if(effect[
"apply_to"] !=
"status") {
664 if(effect[
"add"] == status_name) {
665 current_status =
true;
668 if(effect[
"remove"] == status_name) {
669 current_status =
false;
674 return current_status;
690 if(availability.
blank()) {
694 if(availability.
str() !=
"musthave") {
704 std::vector<std::string>
retval;
707 for(
const variations_map::value_type& val :
variations_) {
708 retval.push_back(val.first);
721 for(
const variations_map::value_type& val :
variations_) {
722 if(!val.second.hide_help()) {
735 if(
auto abilities =
get_cfg().optional_child(
"abilities")) {
737 if(!cfg[
"affect_self"].to_bool(
true)) {
749 if(!resistance_abilities.
empty()) {
752 resistance = 100 - std::min<int>(
754 resistance_abilities.
highest(
"max_value").first
762 const config& cfg,
bool attacker,
const std::string& damage_name,
int res)
const
764 if(!(cfg[
"active_on"].empty() ||
765 (attacker && cfg[
"active_on"] ==
"offense") ||
766 (!attacker && cfg[
"active_on"] ==
"defense"))
771 const std::string& apply_to = cfg[
"apply_to"];
773 if(!apply_to.empty()) {
774 if(damage_name != apply_to) {
775 if(apply_to.find(
',') != std::string::npos && apply_to.find(damage_name) != std::string::npos) {
776 const std::vector<std::string>& vals =
utils::split(apply_to);
778 if(
std::find(vals.begin(), vals.end(), damage_name) == vals.end()) {
801 case unit_alignments::type::lawful:
802 return _(
"female^lawful");
803 case unit_alignments::type::neutral:
804 return _(
"female^neutral");
805 case unit_alignments::type::chaotic:
806 return _(
"female^chaotic");
807 case unit_alignments::type::liminal:
808 return _(
"female^liminal");
810 return _(
"female^lawful");
815 case unit_alignments::type::lawful:
817 case unit_alignments::type::neutral:
819 case unit_alignments::type::chaotic:
821 case unit_alignments::type::liminal:
835 , hide_help_all_(false)
853 void throw_base_unit_recursion_error(
const std::vector<std::string>& base_tree,
const std::string& base_id)
855 std::stringstream ss;
856 ss <<
"[base_unit] recursion loop in [unit_type] ";
858 for(
const std::string& step : base_tree) {
873 const std::string& type_to_patch,
874 const std::string& new_key,
875 const std::string& formula_str,
879 LOG_CONFIG <<
"Patching " << new_key <<
" into movetype." << type_to_patch;
881 mt.
write(mt_cfg,
false);
899 std::list<config> config_copies;
906 const std::array fallback_children {
"movement_costs",
"vision_costs",
"jamming_costs"};
908 for(
const auto& x : fallback_children) {
912 config_copies.emplace_back(cumulative_values);
913 auto val = std::make_shared<wfl::config_callable>(config_copies.back());
914 original.
add(x, val);
917 if(type_to_patch == x) {
923 const std::array child_names {
"defense",
"resistance"};
924 for(
const auto& x : child_names) {
927 auto val = std::make_shared<wfl::config_callable>(subtag);
928 original.
add(x, val);
931 if(type_to_patch == x) {
938 temp_cfg[new_key] = formula.evaluate(original).as_int(default_val);
940 ERR_CF <<
"Error evaluating movetype formula: " << formula_str;
944 mt.
merge(temp_cfg, type_to_patch,
true);
957 if(
type.base_unit_id_.empty()) {
962 if(
std::find(base_tree.begin(), base_tree.end(),
type.base_unit_id_) != base_tree.end()) {
963 throw_base_unit_recursion_error(base_tree,
type.base_unit_id_);
968 if(itor !=
types_.end()) {
973 base_tree.push_back(
type.base_unit_id_);
977 base_tree.pop_back();
980 type.writable_cfg().inherit_from(base_type.
get_cfg());
983 ERR_CF <<
"[base_unit]: unit type not found: " <<
type.base_unit_id_;
995 config var_copy = var_cfg;
996 if(var_cfg[
"inherit"].to_bool(default_inherit)) {
1003 return std::make_unique<unit_type>(std::move(var_copy),
parent_id());
1013 if(!
get_cfg().has_child(
"variation")) {
1018 for(
const config& var_cfg :
get_cfg().child_range(
"variation")) {
1022 var->built_cfg_->remove_children(
"variation");
1023 var->variation_id_ = var_cfg[
"variation_id"].str();
1024 var->debug_id_ =
debug_id_ +
" [" + var->variation_id_ +
"]";
1028 std::tie(ut, success) =
variations_.emplace(var_cfg[
"variation_id"].str(), std::move(*var));
1030 ERR_CF <<
"Skipping duplicate unit variation ID: '" << var_cfg[
"variation_id"]
1031 <<
"' of unit_type '" <<
get_cfg()[
"id"] <<
"'";
1042 if(
auto male_cfg =
get_cfg().optional_child(
"male")) {
1047 if(
auto female_cfg =
get_cfg().optional_child(
"female")) {
1064 LOG_UT <<
"unit_type_data::set_config, nunits: " << cfg.
child_range(
"unit_type").size();
1083 DBG_CF <<
"Start of movetype patching";
1085 const std::string& dmg_type = r[
"id"];
1087 for(
const auto& [mt, value] : r.attribute_range()) {
1092 DBG_CF <<
"Patching specific movetype " << mt;
1093 patch_movetype(
movement_types_[mt],
"resistance", dmg_type, value, 100,
true);
1096 if(r.has_attribute(
"default")) {
1099 if(r.has_attribute(mt.first)) {
1103 if(mt.first ==
"none") {
1107 patch_movetype(mt.second,
"resistance", dmg_type, r[
"default"], 100,
false);
1111 DBG_CF <<
"Split between resistance and cost patching";
1115 const std::string& ter_type = terrain[
"id"];
1117 struct ter_defs_to_movetype
1125 const std::array terrain_info_tags{
1129 ter_defs_to_movetype{{
"defense"}, {
"defense"}, 100}
1132 for(
const auto& cost_type : terrain_info_tags) {
1133 const std::string* src_tag =
nullptr;
1134 if(terrain.has_child(cost_type.subtag)) {
1135 src_tag = &cost_type.subtag;
1137 else if(terrain.has_child(cost_type.alias)) {
1139 src_tag = &cost_type.alias;
1145 const config&
info = terrain.mandatory_child(*src_tag);
1147 for(
const auto& [mt, value] :
info.attribute_range()) {
1153 movement_types_[mt], cost_type.subtag, ter_type, value, cost_type.default_val,
true);
1156 if(
info.has_attribute(
"default")) {
1159 if(
info.has_attribute(mt.first)) {
1163 if(mt.first ==
"none") {
1168 mt.second, cost_type.subtag, ter_type,
info[
"default"], cost_type.default_val,
false);
1173 DBG_CF <<
"End of movetype patching";
1177 std::string
id = ut[
"id"].str();
1179 ERR_CF <<
"[unit_type] with empty id=, ignoring:\n" << ut.debug();
1184 LOG_CONFIG <<
"added " <<
id <<
" to unit_type list (unit_type_data.unit_types)";
1186 ERR_CF <<
"Multiple [unit_type]s with id=" <<
id <<
" encountered.";
1192 std::vector<std::string> base_tree(1,
type.second.id());
1200 type.second.fill_variations_and_gender();
1213 DBG_UT <<
"Finished creating unit types";
1226 if(key.empty() || key ==
"random") {
1230 DBG_CF <<
"trying to find " << key <<
" in unit_type list (unit_type_data.unit_types)";
1234 if(itor ==
types_.end()) {
1235 DBG_CF <<
"unable to find " << key <<
" in unit_type list (unit_type_data.unit_types)";
1242 return &itor->second;
1293 std::vector<std::string> trees =
utils::split(cfg[
"type_adv_tree"]);
1296 for(
const std::string& t_id : trees) {
1300 std::set<std::string> adv_tree = ut->second.advancement_tree();
1319 for(; lvl < lvl_nb; ++lvl) {
1330 race_map::const_iterator
i =
races_.find(key);
1331 return i !=
races_.end() ? &
i->second :
nullptr;
1337 if(
auto p_setxp = cfg.
get(
"set_experience")) {
1340 if(
auto attr = cfg.
get(
"set_advances_to")) {
1343 if(
auto attr = cfg.
get(
"set_cost")) {
1344 cost_ = attr->to_int(1);
1346 if(
auto attr = cfg.
get(
"add_advancement")) {
1353 if(
auto attr = cfg.
get(
"remove_advancement")) {
1364 for(
int gender = 0; gender <= 1; ++gender) {
1369 std::string gender_str = gender == 0 ?
"male" :
"female";
1378 if(
get_cfg().has_child(
"variation")) {
1383 if(v.first == cv[
"variation_id"]){
1384 v.second.apply_scenario_fix(cv);
1395 if(itor !=
types_.end()) {
1396 itor->second.apply_scenario_fix(cfg);
1406 const std::string& advances_to_val =
get_cfg()[
"advances_to"];
1407 if(advances_to_val !=
"null" && !advances_to_val.empty()) {
1414 for(
int gender = 0; gender <= 1; ++gender) {
1421 v.second.remove_scenario_fixes();
1428 for(
auto& pair :
types_) {
1429 pair.second.remove_scenario_fixes();
1435 assert(!
id.empty());
1439 throw error(
"Found unit type id with a leading whitespace \"" +
id +
"\"");
1442 if(
id ==
"random" ||
id ==
"null") {
1443 throw error(
"Found unit type using a 'random' or 'null' as an id");
1446 bool gave_warning =
false;
1448 for(std::size_t pos = 0; pos <
id.size(); ++pos) {
1449 const char c =
id[pos];
1450 const bool valid = std::isalnum(
c, std::locale::classic()) ||
c ==
'_' ||
c ==
' ';
1454 ERR_UT <<
"Found unit type id with invalid characters: \"" <<
id <<
"\"";
1455 gave_warning =
true;
1468 std::string temp = profile;
1470 static const std::string path_adjust =
"/transparent";
1471 const std::string::size_type offset = profile.find_last_of(
'/', profile.find(
'~'));
1474 if(profile.find(path_adjust) != std::string::npos && offset != std::string::npos) {
1476 profile.replace(profile.find(path_adjust), path_adjust.length(),
"");
1483 offset != std::string::npos ? temp.insert(offset, path_adjust) : temp = path_adjust + temp;
boost::iterator_range< boost::indirect_iterator< attack_list::const_iterator > > const_attack_itors
attack_itors make_attack_itors(attack_list &atks)
Variant for storing WML attributes.
std::string str(const std::string &fallback="") const
bool blank() const
Tests for an attribute that was never set.
A config object defines a single node in a WML file, with access to child nodes.
const config & child_or_empty(config_key_type key) const
Returns the first child with the given key, or an empty config if there is none.
config & mandatory_child(config_key_type key, int n=0)
Returns the nth child with the given key, or throws an error if there is none.
auto all_children_view() const
In-order iteration over all children.
void clear_children(T... keys)
bool has_child(config_key_type key) const
Determine whether a config has a child or not.
bool has_attribute(config_key_type key) const
void merge_with(const config &c)
Merge config 'c' into this config, overwriting this config's values.
void inherit_from(const config &c)
Merge config 'c' into this config, preserving this config's values.
child_itors child_range(config_key_type key)
const attribute_value * get(config_key_type key) const
Returns a pointer to the attribute with the given key or nullptr if it does not exist.
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)
A class grating read only view to a vector of config objects, viewed as one config with all children ...
optional_const_config optional_child(config_key_type key) const
static game_config_view wrap(const config &cfg)
config_array_view child_range(config_key_type key) const
static void progress(loading_stage stage=loading_stage::none)
Report what is being loaded to the loading screen.
The basic "size" of the unit - flying, small land, large land, etc.
static const int UNREACHABLE
Magic value that signifies a hex is unreachable.
void write(config &cfg, bool include_notes) const
Writes the movement type data to the provided config.
void merge(const config &new_cfg, bool overwrite=true)
Merges the given config over the existing data, the config should have zero or more children named "m...
int resistance_against(const std::string &damage_type) const
Returns the vulnerability to the indicated damage type (higher means takes more damage).
const std::vector< t_string > & special_notes() const
Contents of any [special_note] tags.
const char * c_str() const
int get_composite_value() const
void emplace_back(T &&... args)
std::pair< int, map_location > highest(const std::string &key, int def=0) const
static void fill_initial_animations(std::vector< unit_animation > &animations, const config &cfg)
const std::string & id() const
bool uses_global_traits() const
static const unit_race null_race
Dummy race used when a race is not yet known.
const std::string & undead_variation() const
unsigned int num_traits() const
const config::const_child_itors & additional_traits() const
static const std::string s_female
Standard string id (not translatable) for FEMALE.
static const std::string s_male
Standard string id (not translatable) for MALE.
void set_config(const game_config_view &cfg)
Resets all data based on the provided config.
unit_type::BUILD_STATUS build_status_
const unit_type * find(const std::string &key, unit_type::BUILD_STATUS status=unit_type::FULL) const
Finds a unit_type by its id() and makes sure it is built to the specified level.
bool hide_help(const std::string &type_id, const std::string &race_id) const
Checks if the [hide_help] tag contains these IDs.
void remove_scenario_fixes()
const race_map & races() const
bool hide_help_all_
True if [hide_help] contains a 'all=yes' at its root.
void build_all(unit_type::BUILD_STATUS status)
Makes sure the all unit_types are built to the specified level.
void apply_base_unit(unit_type &type, std::vector< std::string > &base_tree)
Modifies the provided config by merging all base units into it.
const unit_race * find_race(const std::string &) const
void check_types(const std::vector< std::string > &types) const
movement_type_map movement_types_
game_config_view units_cfg_
void build_unit_type(const unit_type &ut, unit_type::BUILD_STATUS status) const
Makes sure the provided unit_type is built to the specified level.
std::vector< std::set< std::string > > hide_help_type_
const game_config_view & units_cfg() const
const unit_type_map & types() const
void read_hide_help(const config &cfg)
Parses the [hide_help] tag.
void apply_scenario_fix(const config &cfg)
std::vector< std::set< std::string > > hide_help_race_
A single unit type that the player may recruit.
std::string default_variation_
std::vector< unit_animation > animations_
const std::vector< std::string > advances_from() const
A vector of unit_type ids that can advance to this unit_type.
unit_alignments::type alignment_
const std::string & parent_id() const
The id of the original type from which this (variation) descended.
config::const_child_itors advancements_
void fill_variations()
Processes [variation] tags of ut_cfg, handling inheritance and child clearing.
static std::string alignment_description(unit_alignments::type align, unit_race::GENDER gender=unit_race::MALE)
Implementation detail of unit_type::alignment_description.
std::vector< t_string > special_notes_
const unit_type & get_gender_unit_type(const std::string &gender) const
Returns a gendered variant of this unit_type.
variations_map variations_
void build_full(const movement_type_map &movement_types, const race_map &races, const config_array_view &traits)
Load data into an empty unit_type (build to FULL).
const std::string & variation_id() const
The id of this variation; empty if it's a gender variation or a base unit.
const unit_race * race_
Never nullptr, but may point to the null race.
std::string parent_id_
The id of the top ancestor of this unit_type.
std::string undead_variation_
bool has_random_traits() const
std::string movement_type_id_
std::vector< ability_metadata > abilities_
void fill_variations_and_gender()
const movetype & movement_type() const
bool show_variations_in_help() const
Whether the unit type has at least one help-visible variation.
std::string debug_id_
A suffix for id_, used when logging messages.
std::array< std::unique_ptr< unit_type >, 2 > gender_types_
bool has_ability_by_id(const std::string &ability) const
std::string small_profile_
const unit_type & get_variation(const std::string &id) const
const_attack_itors attacks() const
const std::vector< std::string > & advances_to() const
A vector of unit_type ids that this unit_type can advance to.
void apply_scenario_fix(const config &cfg)
int resistance_against(const std::string &damage_name, bool attacker) const
Gets resistance while considering custom WML abilities.
bool has_variation(const std::string &variation_id) const
t_string unit_description() const
static void check_id(std::string &id)
Validate the id argument.
BUILD_STATUS
Records the status of the lazy building of unit types.
const std::vector< unit_animation > & animations() const
std::vector< std::string > variations() const
const std::string & flag_rgb() const
const config & abilities_cfg() const
std::vector< t_string > special_notes() const
Returns all notes that should be displayed in the help page for this type, including those found in a...
attack_list attacks_cache_
std::vector< std::string > advances_to_
std::string base_unit_id_
from [base_unit]
const std::string log_id() const
A variant on id() that is more descriptive, for use with message logging.
std::vector< unit_race::GENDER > genders_
int experience_needed(bool with_acceleration=true) const
bool musthave_status(const std::string &status) const
unit_type(default_ctor_t, const config &cfg, const std::string &parent_id)
void build(BUILD_STATUS status, const movement_type_map &movement_types, const race_map &races, const config_array_view &traits)
Performs a build of this to the indicated stage.
std::vector< std::string > get_ability_list() const
bool resistance_filter_matches(const config &cfg, bool attacker, const std::string &damage_name, int res) const
Identical to unit::resistance_filter_matches.
void remove_scenario_fixes()
std::unique_ptr< unit_type > create_sub_type(const config &var_cfg, bool default_inherit)
Handles inheritance for configs of [male], [female], and [variation].
void build_help_index(const movement_type_map &movement_types, const race_map &races, const config_array_view &traits)
Partially load data into an empty unit_type (build to HELP_INDEXED).
BUILD_STATUS build_status_
config::const_child_itors possible_traits() const
void build_created()
Load the most needed data into an empty unit_type (build to CREATE).
std::unique_ptr< config > built_cfg_
std::vector< ability_metadata > adv_abilities_
const config & get_cfg() const
unsigned int num_traits() const
std::set< std::string > advancement_tree() const
Get the advancement tree.
std::vector< std::reference_wrapper< const config > > config_array_view
static std::string _(const char *str)
std::string id
Text to match against addon_info.tags()
Standard logging facilities (interface).
static void add_color_info(const game_config_view &v, bool build_defaults)
retval
Default window/dialog return values.
bool exists(const image::locator &i_locator)
Returns true if the given image actually exists, without loading it.
std::string substitute_variables(const std::string &str, const std::string &tag_name, const config &ability_or_special)
Substitute gettext variables in name and description of abilities and specials.
bool filter_base_matches(const config &cfg, int def)
void trim(std::string_view &s)
bool contains(const Container &container, const Value &value)
Returns true iff value is found in container.
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::const_iterator iterator
unit_race::GENDER string_gender(const std::string &str, unit_race::GENDER def)
std::map< std::string, unit_race > race_map
Error used for any general game error, e.g.
static const map_location & null_location()
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.
~unit_experience_accelerator()
unit_experience_accelerator(int modifier)
static int get_acceleration()
std::vector< t_string > combine_special_notes(const std::vector< t_string > &direct, const config &abilities, const const_attack_itors &attacks, const movetype &mt)
Common logic for unit_type::special_notes() and unit::special_notes().
static lg::log_domain log_unit("unit")
unit_type_data unit_types
static void advancement_tree_internal(const std::string &id, std::set< std::string > &tree)
void adjust_profile(std::string &profile)
static void append_special_note(std::vector< t_string > ¬es, const t_string &new_note)
static lg::log_domain log_config("config")
std::map< std::string, movetype > movement_type_map