23 #include "formula/callable_objects.hpp"
35 #include <boost/range/algorithm_ext/erase.hpp>
41 #define ERR_CF LOG_STREAM(err, log_config)
42 #define WRN_CF LOG_STREAM(warn, log_config)
43 #define LOG_CONFIG LOG_STREAM(info, log_config)
44 #define DBG_CF LOG_STREAM(debug, log_config)
47 #define DBG_UT LOG_STREAM(debug, log_unit)
48 #define LOG_UT LOG_STREAM(info, log_unit)
49 #define ERR_UT LOG_STREAM(err, log_unit)
56 , id_(cfg.has_attribute(
"id") ? cfg[
"id"].str() : parent_id)
58 , parent_id_(!parent_id.empty() ? parent_id : id_)
63 , hp_bar_scaling_(0.0)
64 , xp_bar_scaling_(0.0)
82 , default_variation_()
91 , advancements_(cfg.child_range(
"advancement"))
92 , experience_needed_(0)
98 , build_status_(NOT_BUILT)
117 built_cfg_ = std::make_unique<config>(std::move(cfg));
126 , name(cfg[
"name"].t_str())
127 , name_inactive(cfg[
"name_inactive"].t_str())
128 , female_name(cfg[
"female_name"].t_str())
129 , female_name_inactive(cfg[
"female_name_inactive"].t_str())
130 , description(cfg[
"description"].t_str())
131 , description_inactive(cfg[
"description_inactive"].t_str())
132 , affect_self(cfg[
"affect_self"].to_bool())
133 , affect_allies(cfg[
"affect_allies"].to_bool())
134 , affect_enemies(cfg[
"affect_enemies"].to_bool())
135 , cumulative(cfg[
"cumulative"].to_bool())
153 for(
int i = 0;
i < 2; ++
i) {
173 for(variations_map::value_type& variation :
variations_) {
174 variation.second.build_full(mv_types, races, traits);
201 level_ = cfg[
"level"].to_int();
204 vision_ = cfg[
"vision"].to_int(-1);
205 jamming_ = cfg[
"jamming"].to_int(0);
207 usage_ = cfg[
"usage"].str();
210 icon_ = cfg[
"image_icon"].str();
224 for(
int i = 0;
i < 2; ++
i) {
231 pair.second.build_help_index(mv_types, races, traits);
234 const race_map::const_iterator race_it = races.find(cfg[
"race"]);
235 if(race_it != races.end()) {
236 race_ = &race_it->second;
254 for(
const auto [key, cfg] : abil_cfg->all_children_view()) {
268 auto abil_cfg = effect.optional_child(
"abilities");
270 if(!abil_cfg || effect[
"apply_to"] !=
"new_ability") {
274 for(
const auto [key, cfg] : abil_cfg->all_children_view()) {
281 const std::string move_type = cfg[
"movement_type"];
283 const movement_type_map::const_iterator find_it = mv_types.find(move_type);
285 if(find_it != mv_types.end()) {
286 DBG_UT <<
"inheriting from movement_type '" << move_type <<
"'";
288 }
else if(!move_type.empty()) {
289 DBG_UT <<
"movement_type '" << move_type <<
"' not found";
295 for(
const config&
t : traits) {
304 if(cfg[
"ignore_race_traits"].to_bool()) {
308 if(
alignment_ != unit_alignments::type::neutral ||
t[
"id"] !=
"fearless")
348 pair.second.build_created();
354 const std::string& advances_to_val = cfg[
"advances_to"];
355 if(advances_to_val !=
"null" && !advances_to_val.empty()) {
363 DBG_UT <<
"unit_type '" <<
log_id() <<
"' advances to : " << advances_to_val;
366 cost_ = cfg[
"cost"].to_int(1);
369 image_ = cfg[
"image"].str();
381 DBG_UT <<
"Building unit type " <<
log_id() <<
", level " << status;
404 ERR_UT <<
"Build of unit_type to unrecognized status (" << status <<
") requested.";
424 const std::size_t
i = gender;
434 const variations_map::const_iterator
i =
variations_.find(
id);
445 return (
_(
"No description available."));
456 if(new_note.
empty())
return;
457 std::string_view note_plain = new_note.
c_str();
459 if(note_plain.empty())
return;
460 auto iter =
std::find(notes.begin(), notes.end(), new_note);
461 if(iter != notes.end())
return;
462 notes.push_back(new_note);
467 std::vector<t_string> notes;
468 for(
const auto& note : direct) {
472 if(cfg.has_attribute(
"special_note")) {
476 for(
const auto& attack :
attacks) {
477 for(
const auto [key, cfg] : attack.specials().all_children_view()) {
478 if(cfg.has_attribute(
"special_note")) {
482 if(
auto attack_type_note =
string_table.find(
"special_note_damage_type_" + attack.type()); attack_type_note !=
string_table.end()) {
516 int experience_modifier = 100;
520 : old_value_(experience_modifier)
522 experience_modifier = modifier;
532 return experience_modifier;
537 if(with_acceleration) {
551 if(
auto abil =
get_cfg().optional_child(
"abilities")) {
552 for(
const auto [key, cfg] : abil->all_children_view()) {
553 if(cfg[
"id"] == ability) {
564 std::vector<std::string> res;
571 for(
const auto [key, cfg] : abilities->all_children_view()) {
572 std::string
id = cfg[
"id"];
575 res.push_back(std::move(
id));
596 if(tree.insert(adv).second) {
605 std::set<std::string> tree;
615 std::vector<std::string> adv_from;
616 for(
const unit_type_data::unit_type_map::value_type& ut :
unit_types.
types()) {
617 for(
const std::string& adv : ut.second.advances_to()) {
619 adv_from.push_back(ut.second.id());
633 bool current_status =
false;
640 if(mod[
"availability"] !=
"musthave") {
650 const std::string& ut = effect[
"unit_type"];
653 const std::vector<std::string>& types =
utils::split(ut);
655 if(
std::find(types.begin(), types.end(),
id()) == types.end()) {
661 if(effect[
"apply_to"] !=
"status") {
665 if(effect[
"add"] == status_name) {
666 current_status =
true;
669 if(effect[
"remove"] == status_name) {
670 current_status =
false;
675 return current_status;
691 if(availability.
blank()) {
695 if(availability.
str() !=
"musthave") {
705 std::vector<std::string>
retval;
708 for(
const variations_map::value_type& val :
variations_) {
709 retval.push_back(val.first);
722 for(
const variations_map::value_type& val :
variations_) {
723 if(!val.second.hide_help()) {
736 if(
auto abilities =
get_cfg().optional_child(
"abilities")) {
738 if(!cfg[
"affect_self"].to_bool(
true)) {
750 if(!resistance_abilities.
empty()) {
753 resistance = 100 - std::min<int>(
755 resistance_abilities.
highest(
"max_value").first
763 const config& cfg,
bool attacker,
const std::string& damage_name,
int res)
const
765 if(!(cfg[
"active_on"].empty() ||
766 (attacker && cfg[
"active_on"] ==
"offense") ||
767 (!attacker && cfg[
"active_on"] ==
"defense"))
772 const std::string& apply_to = cfg[
"apply_to"];
774 if(!apply_to.empty()) {
775 if(damage_name != apply_to) {
776 if(apply_to.find(
',') != std::string::npos && apply_to.find(damage_name) != std::string::npos) {
777 const std::vector<std::string>& vals =
utils::split(apply_to);
779 if(
std::find(vals.begin(), vals.end(), damage_name) == vals.end()) {
802 case unit_alignments::type::lawful:
803 return _(
"female^lawful");
804 case unit_alignments::type::neutral:
805 return _(
"female^neutral");
806 case unit_alignments::type::chaotic:
807 return _(
"female^chaotic");
808 case unit_alignments::type::liminal:
809 return _(
"female^liminal");
811 return _(
"female^lawful");
816 case unit_alignments::type::lawful:
818 case unit_alignments::type::neutral:
820 case unit_alignments::type::chaotic:
822 case unit_alignments::type::liminal:
836 , hide_help_all_(false)
854 void throw_base_unit_recursion_error(
const std::vector<std::string>& base_tree,
const std::string& base_id)
856 std::stringstream ss;
857 ss <<
"[base_unit] recursion loop in [unit_type] ";
859 for(
const std::string& step : base_tree) {
874 const std::string& type_to_patch,
875 const std::string& new_key,
876 const std::string& formula_str,
880 LOG_CONFIG <<
"Patching " << new_key <<
" into movetype." << type_to_patch;
882 mt.
write(mt_cfg,
false);
900 std::list<config> config_copies;
907 const std::array fallback_children {
"movement_costs",
"vision_costs",
"jamming_costs"};
909 for(
const auto& x : fallback_children) {
913 config_copies.emplace_back(cumulative_values);
914 auto val = std::make_shared<wfl::config_callable>(config_copies.back());
915 original.
add(x, val);
918 if(type_to_patch == x) {
924 const std::array child_names {
"defense",
"resistance"};
925 for(
const auto& x : child_names) {
928 auto val = std::make_shared<wfl::config_callable>(subtag);
929 original.
add(x, val);
932 if(type_to_patch == x) {
939 temp_cfg[new_key] = formula(original);
941 ERR_CF <<
"Error evaluating movetype formula: " << formula_str;
945 mt.
merge(temp_cfg, type_to_patch,
true);
958 if(
type.base_unit_id_.empty()) {
963 if(
std::find(base_tree.begin(), base_tree.end(),
type.base_unit_id_) != base_tree.end()) {
964 throw_base_unit_recursion_error(base_tree,
type.base_unit_id_);
969 if(itor !=
types_.end()) {
974 base_tree.push_back(
type.base_unit_id_);
978 base_tree.pop_back();
981 type.writable_cfg().inherit_from(base_type.
get_cfg());
984 ERR_CF <<
"[base_unit]: unit type not found: " <<
type.base_unit_id_;
996 config var_copy = var_cfg;
997 if(var_cfg[
"inherit"].to_bool(default_inherit)) {
1004 return std::make_unique<unit_type>(std::move(var_copy),
parent_id());
1014 if(!
get_cfg().has_child(
"variation")) {
1019 for(
const config& var_cfg :
get_cfg().child_range(
"variation")) {
1023 var->built_cfg_->remove_children(
"variation");
1024 var->variation_id_ = var_cfg[
"variation_id"].str();
1025 var->debug_id_ =
debug_id_ +
" [" + var->variation_id_ +
"]";
1029 std::tie(ut, success) =
variations_.emplace(var_cfg[
"variation_id"].str(), std::move(*var));
1031 ERR_CF <<
"Skipping duplicate unit variation ID: '" << var_cfg[
"variation_id"]
1032 <<
"' of unit_type '" <<
get_cfg()[
"id"] <<
"'";
1043 if(
auto male_cfg =
get_cfg().optional_child(
"male")) {
1048 if(
auto female_cfg =
get_cfg().optional_child(
"female")) {
1065 LOG_UT <<
"unit_type_data::set_config, nunits: " << cfg.
child_range(
"unit_type").size();
1084 DBG_CF <<
"Start of movetype patching";
1086 const std::string& dmg_type = r[
"id"];
1088 for(
const auto& [mt, value] : r.attribute_range()) {
1093 DBG_CF <<
"Patching specific movetype " << mt;
1094 patch_movetype(
movement_types_[mt],
"resistance", dmg_type, value, 100,
true);
1097 if(r.has_attribute(
"default")) {
1100 if(r.has_attribute(mt.first)) {
1104 if(mt.first ==
"none") {
1108 patch_movetype(mt.second,
"resistance", dmg_type, r[
"default"], 100,
false);
1112 DBG_CF <<
"Split between resistance and cost patching";
1116 const std::string& ter_type = terrain[
"id"];
1118 struct ter_defs_to_movetype
1126 const std::array terrain_info_tags{
1130 ter_defs_to_movetype{{
"defense"}, {
"defense"}, 100}
1133 for(
const auto& cost_type : terrain_info_tags) {
1134 const std::string* src_tag =
nullptr;
1135 if(terrain.has_child(cost_type.subtag)) {
1136 src_tag = &cost_type.subtag;
1138 else if(terrain.has_child(cost_type.alias)) {
1140 src_tag = &cost_type.alias;
1146 const config&
info = terrain.mandatory_child(*src_tag);
1148 for(
const auto& [mt, value] :
info.attribute_range()) {
1154 movement_types_[mt], cost_type.subtag, ter_type, value, cost_type.default_val,
true);
1157 if(
info.has_attribute(
"default")) {
1160 if(
info.has_attribute(mt.first)) {
1164 if(mt.first ==
"none") {
1169 mt.second, cost_type.subtag, ter_type,
info[
"default"], cost_type.default_val,
false);
1174 DBG_CF <<
"End of movetype patching";
1178 std::string
id = ut[
"id"].str();
1180 ERR_CF <<
"[unit_type] with empty id=, ignoring:\n" << ut.debug();
1185 LOG_CONFIG <<
"added " <<
id <<
" to unit_type list (unit_type_data.unit_types)";
1187 ERR_CF <<
"Multiple [unit_type]s with id=" <<
id <<
" encountered.";
1193 std::vector<std::string> base_tree(1,
type.second.id());
1201 type.second.fill_variations_and_gender();
1214 DBG_UT <<
"Finished creating unit types";
1227 if(key.empty() || key ==
"random") {
1231 DBG_CF <<
"trying to find " << key <<
" in unit_type list (unit_type_data.unit_types)";
1235 if(itor ==
types_.end()) {
1236 DBG_CF <<
"unable to find " << key <<
" in unit_type list (unit_type_data.unit_types)";
1243 return &itor->second;
1294 std::vector<std::string> trees =
utils::split(cfg[
"type_adv_tree"]);
1297 for(
const std::string& t_id : trees) {
1301 std::set<std::string> adv_tree = ut->second.advancement_tree();
1320 for(; lvl < lvl_nb; ++lvl) {
1331 race_map::const_iterator
i =
races_.find(key);
1332 return i !=
races_.end() ? &
i->second :
nullptr;
1338 if(
auto p_setxp = cfg.
get(
"set_experience")) {
1341 if(
auto attr = cfg.
get(
"set_advances_to")) {
1344 if(
auto attr = cfg.
get(
"set_cost")) {
1345 cost_ = attr->to_int(1);
1347 if(
auto attr = cfg.
get(
"add_advancement")) {
1354 if(
auto attr = cfg.
get(
"remove_advancement")) {
1365 for(
int gender = 0; gender <= 1; ++gender) {
1370 std::string gender_str = gender == 0 ?
"male" :
"female";
1379 if(
get_cfg().has_child(
"variation")) {
1384 if(v.first == cv[
"variation_id"]){
1385 v.second.apply_scenario_fix(cv);
1396 if(itor !=
types_.end()) {
1397 itor->second.apply_scenario_fix(cfg);
1407 const std::string& advances_to_val =
get_cfg()[
"advances_to"];
1408 if(advances_to_val !=
"null" && !advances_to_val.empty()) {
1415 for(
int gender = 0; gender <= 1; ++gender) {
1422 v.second.remove_scenario_fixes();
1429 for(
auto& pair :
types_) {
1430 pair.second.remove_scenario_fixes();
1436 assert(!
id.empty());
1440 throw error(
"Found unit type id with a leading whitespace \"" +
id +
"\"");
1443 if(
id ==
"random" ||
id ==
"null") {
1444 throw error(
"Found unit type using a 'random' or 'null' as an id");
1447 bool gave_warning =
false;
1449 for(std::size_t pos = 0; pos <
id.size(); ++pos) {
1450 const char c =
id[pos];
1451 const bool valid = std::isalnum(
c, std::locale::classic()) ||
c ==
'_' ||
c ==
' ';
1455 ERR_UT <<
"Found unit type id with invalid characters: \"" <<
id <<
"\"";
1456 gave_warning =
true;
1469 std::string temp = profile;
1471 static const std::string path_adjust =
"/transparent";
1472 const std::string::size_type offset = profile.find_last_of(
'/', profile.find(
'~'));
1475 if(profile.find(path_adjust) != std::string::npos && offset != std::string::npos) {
1477 profile.replace(profile.find(path_adjust), path_adjust.length(),
"");
1484 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