47 #include <boost/algorithm/string.hpp>
55 #define WRN_HP LOG_STREAM(warn, log_help)
56 #define DBG_HP LOG_STREAM(debug, log_help)
102 if (ch < 0x2e80)
return false;
106 (ch >= 0x4e00 && ch < 0x9fcf) ||
107 (ch >= 0x3400 && ch < 0x4dbf) ||
108 (ch >= 0x20000 && ch < 0x2a6df) ||
109 (ch >= 0xf900 && ch < 0xfaff) ||
110 (ch >= 0x3190 && ch < 0x319f) ||
113 (ch >= 0x2e80 && ch < 0x2eff) ||
114 (ch >= 0x2f00 && ch < 0x2fdf) ||
115 (ch >= 0x31c0 && ch < 0x31ef) ||
118 (ch >= 0x3104 && ch < 0x312e) ||
119 (ch >= 0x31a0 && ch < 0x31bb) ||
122 (ch >= 0xa490 && ch < 0xa4c7) ||
123 (ch >= 0xa000 && ch < 0xa48d) ||
126 (ch >= 0x3040 && ch <= 0x309f) ||
127 (ch >= 0x30a0 && ch <= 0x30ff) ||
128 (ch >= 0x1b000 && ch <= 0x1b001) ||
131 (ch >= 0x31f0 && ch <= 0x31ff) ||
134 (ch >= 0xac00 && ch < 0xd7af) ||
135 (ch >= 0x1100 && ch <= 0x11ff) ||
136 (ch >= 0xa960 && ch <= 0xa97c) ||
137 (ch >= 0xd7b0 && ch <= 0xd7fb) ||
140 (ch >= 0x3000 && ch < 0x303f) ||
143 (ch >= 0xff00 && ch < 0xffef);
150 const std::vector<std::string> toplevel_refs
152 if (std::find(toplevel_refs.begin(), toplevel_refs.end(), section_id)
153 != toplevel_refs.end()) {
160 const std::vector<std::string> sections_refd
162 if (std::find(sections_refd.begin(), sections_refd.end(), section_id)
163 != sections_refd.end()) {
174 const std::vector<std::string> toplevel_refs
176 if (std::find(toplevel_refs.begin(), toplevel_refs.end(), topic_id)
177 != toplevel_refs.end()) {
184 const std::vector<std::string> topics_refd
186 if (std::find(topics_refd.begin(), topics_refd.end(), topic_id)
187 != topics_refd.end()) {
198 PLAIN_LOG <<
"Maximum section depth has been reached. Maybe circular dependency?";
200 else if (section_cfg !=
nullptr) {
202 std::string
id =
level == 0 ?
"toplevel" : (*section_cfg)[
"id"].str();
205 std::stringstream ss;
206 ss <<
"Invalid ID, used for internal purpose: '" <<
id <<
"'";
210 std::string title =
level == 0 ?
"" : (*section_cfg)[
"title"].str();
213 std::vector<std::string>::const_iterator it;
215 for (it = sections.begin(); it != sections.end(); ++it) {
216 if (
auto child_cfg = help_cfg->
find_child(
"section",
"id", *it))
223 std::stringstream ss;
224 ss <<
"Help-section '" << *it <<
"' referenced from '"
225 <<
id <<
"' but could not be found.";
231 if ((*section_cfg)[
"sort_sections"] ==
"yes") {
235 bool sort_topics =
false;
236 bool sort_generated =
true;
238 if ((*section_cfg)[
"sort_topics"] ==
"yes") {
240 sort_generated =
false;
241 }
else if ((*section_cfg)[
"sort_topics"] ==
"no") {
243 sort_generated =
false;
244 }
else if ((*section_cfg)[
"sort_topics"] ==
"generated") {
246 sort_generated =
true;
247 }
else if (!(*section_cfg)[
"sort_topics"].empty()) {
248 std::stringstream ss;
249 ss <<
"Invalid sort option: '" << (*section_cfg)[
"sort_topics"] <<
"'";
253 std::vector<topic> generated_topics =
generate_topics(sort_generated,(*section_cfg)[
"generator"]);
256 std::vector<topic> topics;
259 for (it = topics_id.begin(); it != topics_id.end(); ++it) {
260 if (
auto topic_cfg = help_cfg->
find_child(
"topic",
"id", *it))
262 std::string text = topic_cfg[
"text"];
264 topic child_topic(topic_cfg[
"title"], topic_cfg[
"id"], text);
266 std::stringstream ss;
267 ss <<
"Invalid ID, used for internal purpose: '" <<
id <<
"'";
270 topics.push_back(child_topic);
273 std::stringstream ss;
274 ss <<
"Help-topic '" << *it <<
"' referenced from '" <<
id
275 <<
"' but could not be found." << std::endl;
281 std::sort(topics.begin(),topics.end(),
title_less());
282 std::sort(generated_topics.begin(),
284 std::merge(generated_topics.begin(),
285 generated_topics.end(),topics.begin(),topics.end()
290 topics.begin(), topics.end());
292 generated_topics.begin(), generated_topics.end());
300 if (cfg !=
nullptr) {
309 std::vector<topic> res;
316 }
else if (
generator ==
"weapon_specials") {
318 }
else if (
generator ==
"time_of_days") {
324 if (parts.size() > 1 && parts[0] ==
"units") {
326 }
else if (parts[0] ==
"era" && parts.size()>1) {
329 WRN_HP <<
"Found a topic generator that I didn't recognize: " <<
generator;
343 DBG_HP <<
"Generating eras...";
347 if (parts.size() > 1 && parts[0] ==
"units") {
350 WRN_HP <<
"Found a section generator that I didn't recognize: " <<
generator;
357 std::string empty_string =
"";
362 if (parts.size() > 1 && parts[0] ==
"contents") {
363 if (parts[1] ==
"generated") {
391 return markup::span_color((time_of_day_bonus > 0 ?
"green" : (time_of_day_bonus < 0 ?
"red" :
"white")), time_of_day_bonus);
396 std::vector<topic> topics;
397 std::stringstream toplevel;
400 toplevel <<
_(
"Only available during a scenario.");
401 topics.emplace_back(
_(
"Time of Day Schedule"),
"..schedule", toplevel.str());
408 const std::string
id =
"time_of_day_" + time.id;
410 const std::string image_lawful =
markup::img(
"icons/alignments/alignment_lawful_30.png");
411 const std::string image_neutral =
markup::img(
"icons/alignments/alignment_neutral_30.png");
412 const std::string image_chaotic =
markup::img(
"icons/alignments/alignment_chaotic_30.png");
413 const std::string image_liminal =
markup::img(
"icons/alignments/alignment_liminal_30.png");
414 std::stringstream text, row_ss;
429 text <<
image <<
'\n'
430 << time.description.str() <<
'\n'
437 topics.emplace_back(time.name.str(),
id, text.str());
440 topics.emplace_back(
_(
"Time of Day Schedule"),
"..schedule",
markup::tag(
"table", toplevel.str()));
446 std::vector<topic> topics;
448 std::map<t_string, std::string> special_description;
449 std::map<t_string, std::set<std::string, string_less>> special_units;
451 for (
const unit_type_data::unit_type_map::value_type &type_mapping :
unit_types.
types())
461 std::vector<std::pair<t_string, t_string>> specials = atk.special_tooltips();
462 for ( std::size_t
i = 0;
i != specials.size(); ++
i )
464 special_description.emplace(specials[
i].first, specials[
i].second);
466 if (!
type.hide_help()) {
468 std::string type_name =
type.type_name();
470 const std::string section_prefix =
type.show_variations_in_help() ?
".." :
"";
475 special_units[specials[
i].first].insert(link);
480 for(
config adv :
type.modification_advancements()) {
482 if(effect[
"apply_to"] ==
"new_attack" && effect.has_child(
"specials")) {
483 for(
const auto [key, special] : effect.mandatory_child(
"specials").all_children_view()) {
484 if(!special[
"name"].empty()) {
485 special_description.emplace(special[
"name"].t_str(), special[
"description"].t_str());
486 if(!
type.hide_help()) {
488 std::string type_name =
type.type_name();
490 const std::string section_prefix =
type.show_variations_in_help() ?
".." :
"";
495 special_units[special[
"name"]].insert(link);
499 }
else if(effect[
"apply_to"] ==
"attack" && effect.has_child(
"set_specials")) {
500 for(
const auto [key, special] : effect.mandatory_child(
"set_specials").all_children_view()) {
501 if(!special[
"name"].empty()) {
502 special_description.emplace(special[
"name"].t_str(), special[
"description"].t_str());
503 if(!
type.hide_help()) {
505 std::string type_name =
type.type_name();
507 const std::string section_prefix =
type.show_variations_in_help() ?
".." :
"";
512 special_units[special[
"name"]].insert(link);
522 s != special_description.end(); ++
s) {
524 std::string
id =
"weaponspecial_" +
s->first.base_str();
525 std::stringstream text;
527 text <<
"\n\n" <<
_(
"<header>text='Units with this special attack'</header>") <<
"\n";
528 std::set<std::string, string_less> &units = special_units[
s->first];
533 topics.emplace_back(
s->first,
id, text.str());
537 std::sort(topics.begin(), topics.end(),
title_less());
543 std::vector<topic> topics;
545 std::map<std::string, const unit_type::ability_metadata*> ability_topic_data;
546 std::map<std::string, std::set<std::string, string_less>> ability_units;
553 const std::string topic_ref = ability.id + ability.name.base_str();
555 ability_topic_data.emplace(topic_ref, &ability);
557 if(!
type.hide_help()) {
562 ability_units[topic_ref].insert(link);
577 parse(
type, ability);
581 parse(
type, ability);
585 for(
const auto& a : ability_topic_data) {
586 if (a.second->name.empty()) {
589 std::ostringstream text;
590 text << a.second->description;
591 text <<
"\n\n" <<
_(
"<header>text='Units with this ability'</header>") <<
"\n";
593 for(
const auto& u : ability_units[a.first]) {
597 topics.emplace_back(a.second->name,
ability_prefix + a.first, text.str());
601 std::sort(topics.begin(), topics.end(),
title_less());
609 std::vector<topic> topics;
612 if(era && !era[
"hide_help"].to_bool()) {
615 std::vector<std::string> faction_links;
616 for (
const topic &
t : topics) {
620 std::stringstream text;
621 text <<
markup::tag(
"header",
_(
"Era:"),
" ", era[
"name"]) <<
"\n";
624 if (!description.
empty()) {
625 text << description.
t_str() <<
"\n";
631 std::sort(faction_links.begin(), faction_links.end());
632 for (
const std::string &link : faction_links) {
636 topic era_topic(era[
"name"],
".." +
era_prefix + era[
"id"].str(), text.str());
638 topics.push_back( era_topic );
645 std::vector<topic> topics;
647 const std::string&
id =
f[
"id"];
651 std::stringstream text;
654 if (!description.
empty()) {
655 text << description.
t_str() <<
"\n";
659 const std::vector<std::string> recruit_ids =
utils::split(
f[
"recruit"]);
660 std::set<std::string> races;
661 std::set<std::string> alignments;
663 for (
const std::string & u_id : recruit_ids) {
675 if (!races.empty()) {
677 text <<
_(
"Races: ") << *(it++);
678 while(it != races.end()) {
679 text <<
", " << *(it++);
684 if (!alignments.empty()) {
686 text <<
_(
"Alignments: ") << *(it++);
687 while(it != alignments.end()) {
688 text <<
", " << *(it++);
694 const std::vector<std::string> leaders =
696 for (
const std::string &link : leaders) {
703 const std::vector<std::string> recruit_links =
705 for (
const std::string &link : recruit_links) {
709 const std::string name =
f[
"name"];
711 topics.emplace_back(name, ref_id, text.str());
714 std::sort(topics.begin(), topics.end(),
title_less());
723 std::map<std::string, const config> trait_list;
727 trait_list.emplace(trait[
"id"], trait);
731 std::set<std::string> races;
742 races.insert(
type.race_id());
752 for (
const config& trait :
type.possible_traits()) {
753 trait_list.emplace(trait[
"id"], trait);
763 for(
const auto& race_id : races) {
765 for(
const config & trait : r->additional_traits()) {
766 trait_list.emplace(trait[
"id"], trait);
771 std::vector<topic> topics;
772 for(
auto& a : trait_list) {
773 std::string
id =
"traits_" + a.first;
774 const config& trait = a.second;
776 std::string name = trait[
"male_name"].str();
777 if (name.empty()) name = trait[
"female_name"].str();
778 if (name.empty()) name = trait[
"name"].str();
779 if (name.empty())
continue;
781 std::stringstream text;
782 if (!trait[
"help_text"].empty()) {
783 text << trait[
"help_text"];
784 }
else if (!trait[
"description"].empty()) {
785 text << trait[
"description"];
787 text <<
_(
"No description available.");
791 topics.emplace_back(name,
id, text.str());
795 std::sort(topics.begin(), topics.end(),
title_less());
806 PLAIN_LOG <<
"Unknown unit type : " << type_id;
810 }
else if (!
type->hide_help()) {
811 std::string name =
type->type_name();
814 const std::string section_prefix =
type->show_variations_in_help() ?
".." :
"";
828 std::vector<std::string> links_list;
829 for (
const std::string &type_id : type_id_list) {
831 if (!unit_link.empty())
832 links_list.push_back(unit_link);
836 std::sort(links_list.begin(), links_list.end());
843 std::set<std::string, string_less> races;
844 std::set<std::string, string_less> visible_races;
851 races.insert(
type.race_id());
852 if(!
type.hide_help())
853 visible_races.insert(
type.race_id());
858 std::set<std::string, string_less> last_sweep = visible_races;
859 while(!last_sweep.empty()) {
860 std::set<std::string, string_less> current_sweep;
861 for(
const auto& race_id : last_sweep) {
863 const auto& help_taxonomy = r->help_taxonomy();
864 if(!help_taxonomy.empty() && !visible_races.count(help_taxonomy) &&
unit_types.
find_race(help_taxonomy)) {
865 current_sweep.insert(help_taxonomy);
866 races.insert(help_taxonomy);
867 visible_races.insert(help_taxonomy);
871 last_sweep = std::move(current_sweep);
874 struct taxonomy_queue_type
876 std::string parent_id;
879 std::vector<taxonomy_queue_type> taxonomy_queue;
883 for(
const auto& race_id : races) {
887 bool hidden = (visible_races.count(race_id) == 0);
892 std::string help_taxonomy;
894 title = r->plural_name();
895 help_taxonomy = r->help_taxonomy();
897 title =
_(
"race^Miscellaneous");
900 section_cfg[
"title"] = title;
902 section_cfg[
"sections_generator"] =
"units:" + race_id;
903 section_cfg[
"generator"] =
"units:" + race_id;
907 if(help_taxonomy.empty()) {
910 bool parent_hidden = (visible_races.count(help_taxonomy) == 0);
912 taxonomy_queue.push_back({std::move(parent_id), std::move(race_section)});
917 bool process_queue_again =
true;
918 while(process_queue_again && !taxonomy_queue.empty()) {
919 process_queue_again =
false;
920 std::vector<taxonomy_queue_type> to_process = std::move(taxonomy_queue);
922 for(
auto& x : to_process) {
925 parent->add_section(std::move(x.content));
926 process_queue_again =
true;
928 taxonomy_queue.push_back(std::move(x));
934 for(
auto& x : taxonomy_queue) {
942 if (era[
"hide_help"].to_bool()) {
946 DBG_HP <<
"Adding help section: " << era[
"id"].str();
950 section_cfg[
"id"] =
era_prefix + era[
"id"].str();
951 section_cfg[
"title"] = era[
"name"];
953 section_cfg[
"generator"] =
"era:" + era[
"id"].str();
967 WRN_HP <<
"When building terrain help sections, couldn't acquire terrain types data, aborting.";
971 std::map<std::string, section> base_map;
979 bool hidden =
info.hide_help();
982 ==
prefs::get().encountered_terrains().end() && !
info.is_overlay())
986 terrain_topic.
title =
info.editor_name();
988 terrain_topic.
text = std::make_shared<terrain_topic_generator>(
info);
991 if (
info.has_default_base()) {
992 for (
const auto base : tdata->underlying_union_terrain(
info.default_base())) {
994 base_terrains.emplace_back(base);
1000 const terrain_type& base_info = tdata->get_terrain_info(base);
1005 section& base_section = base_map[base_info.
id()];
1010 if (base_info.
id() ==
info.id())
1012 base_section.
topics.push_back(terrain_topic);
1016 for (
const auto& base : base_map) {
1023 for (
const unit_type_data::unit_type_map::value_type &
i :
unit_types.
types()) {
1026 if (
type.race_id() != race)
1029 if (!
type.show_variations_in_help())
1033 for (
const std::string &variation_id :
type.variations()) {
1035 const unit_type &var_type =
type.get_variation(variation_id);
1039 topic var_topic(topic_name, var_ref,
"");
1040 var_topic.
text = std::make_shared<unit_topic_generator>(var_type, variation_id);
1041 base_unit.
topics.push_back(var_topic);
1044 const std::string type_name =
type.type_name();
1047 base_unit.
id = ref_id;
1048 base_unit.
title = type_name;
1056 std::vector<topic> topics;
1057 std::set<std::string, string_less> race_units;
1058 std::set<std::string, string_less> race_topics;
1059 std::set<std::string> alignments;
1061 for (
const unit_type_data::unit_type_map::value_type &
i :
unit_types.
types())
1065 if (
type.race_id() != race)
1073 const std::string type_name =
type.type_name() + (
type.id() ==
type.type_name().str() ?
"" : debug_suffix);
1074 const std::string real_prefix =
type.show_variations_in_help() ?
".." :
"";
1076 topic unit_topic(type_name, ref_id,
"");
1077 unit_topic.
text = std::make_shared<unit_topic_generator>(
type);
1078 topics.push_back(unit_topic);
1080 if (!
type.hide_help()) {
1084 race_units.insert(link);
1091 std::string race_id =
"..race_"+race;
1092 std::string race_name;
1093 std::string race_description;
1094 std::string race_help_taxonomy;
1096 race_name = r->plural_name();
1097 race_description = r->description();
1098 race_help_taxonomy = r->help_taxonomy();
1100 for (
const config &additional_topic : r->additional_topics())
1102 std::string
id = additional_topic[
"id"];
1103 std::string title = additional_topic[
"title"];
1104 std::string text = additional_topic[
"text"];
1106 topics.emplace_back(title,
id,text);
1108 race_topics.insert(link);
1111 race_name =
_ (
"race^Miscellaneous");
1116 std::map<std::string, t_string> subgroups;
1118 if (r.second.help_taxonomy() == race) {
1119 if (!r.second.plural_name().empty())
1120 subgroups[r.first] = r.second.plural_name();
1122 subgroups[r.first] = r.first;
1126 std::stringstream text;
1128 if (!race_description.empty()) {
1129 text << race_description <<
"\n\n";
1132 if (!alignments.empty()) {
1134 text << (alignments.size() > 1 ?
_(
"Alignments: ") :
_(
"Alignment: ")) << *(it++);
1135 while(it != alignments.end()) {
1136 text <<
", " << *(it++);
1141 if (!race_help_taxonomy.empty()) {
1143 symbols[
"topic_id"] =
"..race_"+race_help_taxonomy;
1145 symbols[
"help_taxonomy"] = r->plural_name();
1149 symbols[
"help_taxonomy"] = race_help_taxonomy;
1153 text <<
VGETTEXT(
"This is a group of units, all of whom are <ref>dst='$topic_id' text='$help_taxonomy'</ref>.", symbols) <<
"\n\n";
1156 if (!subgroups.empty()) {
1157 if (!race_help_taxonomy.empty()) {
1158 text <<
_(
"<header>text='Subgroups of units within this group'</header>") <<
"\n";
1160 text <<
_(
"<header>text='Groups of units within this race'</header>") <<
"\n";
1162 for (
const auto &sg : subgroups) {
1168 if (!race_help_taxonomy.empty()) {
1169 text <<
_(
"<header>text='Units of this group'</header>") <<
"\n";
1171 text <<
_(
"<header>text='Units of this race'</header>") <<
"\n";
1173 for (
const auto &u : race_units) {
1177 topics.emplace_back(race_name, race_id, text.str());
1180 std::sort(topics.begin(), topics.end(),
title_less());
1193 if (encountered_units.find(
type.id()) != encountered_units.end()) {
1198 if (
type.id() ==
"Fog Clearer") {
1207 auto section_cfg = help_cfg->
find_child(
"section",
"id", section_name);
1209 return std::string();
1212 std::ostringstream res;
1217 typedef std::pair<std::string,std::string> link;
1218 std::vector<link> topics_links;
1222 for (
t = topics.begin();
t != topics.end(); ++
t) {
1223 if (
auto topic_cfg = help_cfg->
find_child(
"topic",
"id", *
t)) {
1224 std::string
id = topic_cfg[
"id"];
1226 topics_links.emplace_back(topic_cfg[
"title"],
id);
1230 if (section_cfg[
"sort_topics"] ==
"yes") {
1231 std::sort(topics_links.begin(),topics_links.end());
1235 for (l = topics_links.begin(); l != topics_links.end(); ++l) {
1245 std::stringstream res;
1275 return sec.
id ==
id;
1296 topic_list::const_iterator tit =
1298 if (tit != sec.
topics.end()) {
1317 for (
const auto &subsection : sec.
sections) {
1333 if (text.length() > 0 && text[0] ==
' ') {
1334 return text.substr(1);
1341 std::size_t first_word_start =
s.find_first_not_of(
' ');
1342 if (first_word_start == std::string::npos) {
1345 std::size_t first_word_end =
s.find_first_of(
" \n", first_word_start);
1346 if( first_word_end == first_word_start ) {
1348 first_word_end = first_word_start+1;
1352 std::string re =
s.substr(0, first_word_end);
1358 char32_t firstchar = *ch;
1360 re = unicode_cast<std::string>(firstchar);
1380 std::stringstream ss;
1383 const std::string
id =
section[
"id"];
1389 if (!ss.str().empty()) {
1396 hidden_toplevel[
"sections"] = ss.str();
1400 const std::string
id =
topic[
"id"];
1403 if (!ss.str().empty()) {
1410 hidden_toplevel[
"topics"] = ss.str();
1411 config hidden_cfg = *help_config;
1414 hidden_cfg.
add_child(
"toplevel", std::move(hidden_toplevel));
1418 std::stringstream
msg;
1419 msg <<
"Parse error when parsing help text: '" <<
e.message <<
"'";
1427 return (hidden ?
"." :
"");
1431 return (
id.empty() ||
id[0] !=
'.');
1440 if (
id ==
"toplevel") {
1446 if (
id.
compare(0, 8,
"ability_") == 0) {
1449 if (
id.
compare(0, 14,
"weaponspecial_") == 0) {
1452 if (
id ==
"hidden") {
int generic_combat_modifier(int lawful_bonus, unit_alignments::type alignment, bool is_fearless, int max_liminal_bonus)
Returns the amount that a unit's damage should be multiplied by due to a given lawful_bonus.
Various functions that implement attacks and attack calculations.
Variant for storing WML attributes.
bool empty() const
Tests for an attribute that either was never set or was set to "".
A config object defines a single node in a WML file, with access to child nodes.
optional_config_impl< config > find_child(config_key_type key, const std::string &name, const std::string &value)
Returns the first child of tag key with a name attribute containing value.
void clear_children(T... keys)
child_itors child_range(config_key_type key)
std::string debug() 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)
static game_config_manager * get()
const std::shared_ptr< terrain_type_data > & terrain_types() const
A class grating read only view to a vector of config objects, viewed as one config with all children ...
const config & child_or_empty(config_key_type key) const
optional_const_config find_child(config_key_type key, const std::string &name, const std::string &value) const
config_array_view child_range(config_key_type key) const
To be used as a function object to locate sections and topics with a specified ID.
To be used as a function object when sorting section lists on the title.
To be used as a function object when sorting topic lists on the title.
The text displayed in a topic.
std::shared_ptr< topic_generator > generator_
topic_text & operator=(topic_text &&t)=default
const config & parsed_text() const
std::set< std::string > & encountered_units()
bool hide_help() const
For instances created from a [terrain_type] tag, the value in the tag (with default false).
bool is_nonnull() const
True if this object represents some sentinel values.
const std::string & id() const
const t_string & editor_name() const
int get_max_liminal_bonus() const
const std::vector< time_of_day > & times(const map_location &loc=map_location::null_location()) const
static iterator_base end(const string_type &str)
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.
const race_map & races() const
const unit_race * find_race(const std::string &) const
const unit_type_map & types() const
config_array_view traits() const
A single unit type that the player may recruit.
const std::string & id() const
The id for this unit_type.
const t_string & variation_name() const
static std::string _(const char *str)
std::string id
Text to match against addon_info.tags()
static lg::log_domain log_help("help")
Standard logging facilities (interface).
const std::string unicode_bullet
std::string get_first_word(const std::string &s)
Return the first word in s, not removing any spaces in the start of it.
std::vector< topic > generate_unit_topics(const bool sort_generated, const std::string &race)
std::string hidden_symbol(bool hidden)
void generate_unit_sections(const config *, section &sec, int, const bool, const std::string &race)
@ HIDDEN_BUT_SHOW_MACROS
Although the unit itself is hidden, traits reachable via this unit are not hidden.
@ NO_DESCRIPTION
Ignore this unit for documentation purposes.
void generate_races_sections(const config *help_cfg, section &sec, int level)
bool topic_is_referenced(const std::string &topic_id, const config &cfg)
Return true if the topic with id topic_id is referenced from another section in the config,...
std::vector< topic > generate_time_of_day_topics(const bool)
int last_num_encountered_units
void generate_terrain_sections(section &sec, int)
std::string make_unit_link(const std::string &type_id)
return a hyperlink with the unit's name and pointing to the unit page return empty string if this uni...
const std::string open_section_img
const std::string unit_prefix
const std::string variation_prefix
void parse_config_internal(const config *help_cfg, const config *section_cfg, section &sec, int level)
Recursive function used by parse_config.
bool is_visible_id(const std::string &id)
const std::string closed_section_img
std::vector< topic > generate_faction_topics(const config &era, const bool sort_generated)
void generate_sections(const config *help_cfg, const std::string &generator, section &sec, int level)
Dispatch generators to their appropriate functions.
const std::string topic_img
UNIT_DESCRIPTION_TYPE description_type(const unit_type &type)
Return the type of description that should be shown for a unit of the given kind.
const std::string race_prefix
const std::string ability_prefix
std::vector< std::string > make_unit_links_list(const std::vector< std::string > &type_id_list, bool ordered)
return a list of hyperlinks to unit's pages (ordered or not)
std::vector< topic > generate_topics(const bool sort_generated, const std::string &generator)
const section * find_section(const section &sec, const std::string &id)
Search for the section with the specified identifier in the section and its subsections.
static std::string time_of_day_bonus_colored(const int time_of_day_bonus)
const int normal_font_size
void generate_contents()
Generate the help contents from the configurations given to the manager.
const std::string terrain_prefix
std::vector< topic > generate_weapon_special_topics(const bool sort_generated)
std::vector< topic > generate_ability_topics(const bool sort_generated)
std::string remove_first_space(const std::string &text)
const std::string unknown_unit_topic
const int max_section_level
const unsigned max_history
std::vector< std::string > empty_string_vector
bool section_is_referenced(const std::string §ion_id, const config &cfg)
Return true if the section with id section_id is referenced from another section in the config,...
std::shared_ptr< terrain_type_data > load_terrain_types_data()
Load the appropriate terrain types data to use.
bool is_valid_id(const std::string &id)
Return true if the id is valid for user defined topics and sections.
boost::tribool last_debug_state
std::string generate_contents_links(const std::string §ion_name, config const *help_cfg)
std::string generate_topic_text(const std::string &generator, const config *help_cfg, const section &sec)
help::section default_toplevel
const topic * find_topic(const section &sec, const std::string &id)
Search for the topic with the specified identifier in the section and its subsections.
section parse_config(const config *cfg)
Parse a help config, return the top level section.
std::vector< topic > generate_era_topics(const bool sort_generated, const std::string &era_id)
const game_config_view * game_cfg
int last_num_encountered_terrains
help::section hidden_sections
std::vector< topic > generate_trait_topics(const bool sort_generated)
const std::string default_show_topic
void generate_era_sections(const config *help_cfg, section &sec, int level)
static bool is_cjk_char(const char32_t ch)
const std::string era_prefix
const std::string faction_prefix
bool is_scope_active(scope s)
Functions to load and save images from/to disk.
std::string make_link(const std::string &text, const std::string &dst)
std::string img(const std::string &src, const std::string &align, const bool floating)
std::string tag(const std::string &tag_name, Args &&... contents)
Returns the contents enclosed inside <tag_name> and </tag_name>
std::string span_color(const color_t &color, Args &&... data)
Returns a Pango formatting string using the provided color_t object.
config parse_text(const std::string &text)
Parse a xml style marked up text string.
rng * generator
This generator is automatically synced during synced context.
::tod_manager * tod_manager
std::vector< terrain_code > ter_list
int compare(const std::string &s1, const std::string &s2)
Case-sensitive lexicographical comparison.
@ STRIP_SPACES
REMOVE_EMPTY: remove empty elements.
std::vector< std::string > quoted_split(const std::string &val, char c, int flags, char quote)
This function is identical to split(), except it does not split when it otherwise would if the previo...
bool contains(const Container &container, const Value &value)
Returns true iff value is found in container.
std::map< std::string, t_string > string_map
std::vector< std::string > split(const config_attribute_value &val)
std::string::const_iterator iterator
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Thrown when the help system fails to parse something.
A section contains topics and sections along with title and ID.
bool operator<(const section &) const
Comparison on the ID.
void add_section(const section &s)
Allocate memory for and add the section.
bool operator==(const section &) const
Two sections are equal if their IDs are equal.
A topic contains a title, an id and some text.
bool operator==(const topic &) const
Two topics are equal if their IDs are equal.
bool operator<(const topic &) const
Comparison on the ID.
A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separa...
Object which defines a time of day with associated bonuses, image, sounds etc.
static map_location::direction s
unit_type_data unit_types