56 #define WRN_DP LOG_STREAM(warn, log_display)
59 #define WRN_HP LOG_STREAM(warn, log_help)
60 #define DBG_HP LOG_STREAM(debug, log_help)
106 if (ch < 0x2e80)
return false;
110 (ch >= 0x4e00 && ch < 0x9fcf) ||
111 (ch >= 0x3400 && ch < 0x4dbf) ||
112 (ch >= 0x20000 && ch < 0x2a6df) ||
113 (ch >= 0xf900 && ch < 0xfaff) ||
114 (ch >= 0x3190 && ch < 0x319f) ||
117 (ch >= 0x2e80 && ch < 0x2eff) ||
118 (ch >= 0x2f00 && ch < 0x2fdf) ||
119 (ch >= 0x31c0 && ch < 0x31ef) ||
122 (ch >= 0x3104 && ch < 0x312e) ||
123 (ch >= 0x31a0 && ch < 0x31bb) ||
126 (ch >= 0xa490 && ch < 0xa4c7) ||
127 (ch >= 0xa000 && ch < 0xa48d) ||
130 (ch >= 0x3040 && ch <= 0x309f) ||
131 (ch >= 0x30a0 && ch <= 0x30ff) ||
132 (ch >= 0x1b000 && ch <= 0x1b001) ||
135 (ch >= 0x31f0 && ch <= 0x31ff) ||
138 (ch >= 0xac00 && ch < 0xd7af) ||
139 (ch >= 0x1100 && ch <= 0x11ff) ||
140 (ch >= 0xa960 && ch <= 0xa97c) ||
141 (ch >= 0xd7b0 && ch <= 0xd7fb) ||
144 (ch >= 0x3000 && ch < 0x303f) ||
147 (ch >= 0xff00 && ch < 0xffef);
154 const std::vector<std::string> toplevel_refs
156 if (std::find(toplevel_refs.begin(), toplevel_refs.end(), section_id)
157 != toplevel_refs.end()) {
164 const std::vector<std::string> sections_refd
166 if (std::find(sections_refd.begin(), sections_refd.end(), section_id)
167 != sections_refd.end()) {
178 const std::vector<std::string> toplevel_refs
180 if (std::find(toplevel_refs.begin(), toplevel_refs.end(), topic_id)
181 != toplevel_refs.end()) {
188 const std::vector<std::string> topics_refd
190 if (std::find(topics_refd.begin(), topics_refd.end(), topic_id)
191 != topics_refd.end()) {
202 PLAIN_LOG <<
"Maximum section depth has been reached. Maybe circular dependency?";
204 else if (section_cfg !=
nullptr) {
206 std::string
id =
level == 0 ?
"toplevel" : (*section_cfg)[
"id"].str();
209 std::stringstream ss;
210 ss <<
"Invalid ID, used for internal purpose: '" <<
id <<
"'";
214 std::string title =
level == 0 ?
"" : (*section_cfg)[
"title"].str();
217 std::vector<std::string>::const_iterator it;
219 for (it = sections.begin(); it != sections.end(); ++it) {
220 if (
auto child_cfg = help_cfg->
find_child(
"section",
"id", *it))
227 std::stringstream ss;
228 ss <<
"Help-section '" << *it <<
"' referenced from '"
229 <<
id <<
"' but could not be found.";
235 if ((*section_cfg)[
"sort_sections"] ==
"yes") {
239 bool sort_topics =
false;
240 bool sort_generated =
true;
242 if ((*section_cfg)[
"sort_topics"] ==
"yes") {
244 sort_generated =
false;
245 }
else if ((*section_cfg)[
"sort_topics"] ==
"no") {
247 sort_generated =
false;
248 }
else if ((*section_cfg)[
"sort_topics"] ==
"generated") {
250 sort_generated =
true;
251 }
else if (!(*section_cfg)[
"sort_topics"].empty()) {
252 std::stringstream ss;
253 ss <<
"Invalid sort option: '" << (*section_cfg)[
"sort_topics"] <<
"'";
257 std::vector<topic> generated_topics =
261 std::vector<topic> topics;
264 for (it = topics_id.begin(); it != topics_id.end(); ++it) {
265 if (
auto topic_cfg = help_cfg->
find_child(
"topic",
"id", *it))
267 std::string text = topic_cfg[
"text"];
269 topic child_topic(topic_cfg[
"title"], topic_cfg[
"id"], text);
271 std::stringstream ss;
272 ss <<
"Invalid ID, used for internal purpose: '" <<
id <<
"'";
275 topics.push_back(child_topic);
278 std::stringstream ss;
279 ss <<
"Help-topic '" << *it <<
"' referenced from '" <<
id
280 <<
"' but could not be found." << std::endl;
286 std::sort(topics.begin(),topics.end(),
title_less());
287 std::sort(generated_topics.begin(),
289 std::merge(generated_topics.begin(),
290 generated_topics.end(),topics.begin(),topics.end()
295 topics.begin(), topics.end());
297 generated_topics.begin(), generated_topics.end());
305 if (cfg !=
nullptr) {
314 std::vector<topic> res;
321 }
else if (
generator ==
"weapon_specials") {
323 }
else if (
generator ==
"time_of_days") {
329 if (parts.size() > 1 && parts[0] ==
"units") {
331 }
else if (parts[0] ==
"era" && parts.size()>1) {
334 WRN_HP <<
"Found a topic generator that I didn't recognize: " <<
generator;
348 DBG_HP <<
"Generating eras...";
352 if (parts.size() > 1 && parts[0] ==
"units") {
355 WRN_HP <<
"Found a section generator that I didn't recognize: " <<
generator;
362 std::string empty_string =
"";
367 if (parts.size() > 1 && parts[0] ==
"contents") {
368 if (parts[1] ==
"generated") {
396 return std::string(
"<format>color='") + (time_of_day_bonus > 0 ?
"green" : (time_of_day_bonus < 0 ?
"red" :
"white")) +
"' text='" + std::to_string(time_of_day_bonus) +
"'</format>";
401 std::vector<topic> topics;
402 std::stringstream toplevel;
405 toplevel <<
_(
"Only available during a scenario.");
406 topics.emplace_back(
_(
"Time of Day Schedule"),
"..schedule", toplevel.str());
413 const std::string
id =
"time_of_day_" + time.id;
414 const std::string
image =
"<img>src='" + time.image +
"'</img>";
415 const std::string image_lawful =
"<img>src='icons/alignments/alignment_lawful_30.png'</img>";
416 const std::string image_neutral =
"<img>src='icons/alignments/alignment_neutral_30.png'</img>";
417 const std::string image_chaotic =
"<img>src='icons/alignments/alignment_chaotic_30.png'</img>";
418 const std::string image_liminal =
"<img>src='icons/alignments/alignment_liminal_30.png'</img>";
419 std::stringstream text;
432 text <<
image <<
'\n' << time.description.str() <<
'\n' <<
437 '\n' <<
make_link(
_(
"Schedule"),
"..schedule");
439 topics.emplace_back(time.name.str(),
id, text.str());
442 topics.emplace_back(
_(
"Time of Day Schedule"),
"..schedule", toplevel.str());
448 std::vector<topic> topics;
450 std::map<t_string, std::string> special_description;
451 std::map<t_string, std::set<std::string, string_less>> special_units;
453 for (
const unit_type_data::unit_type_map::value_type &type_mapping :
unit_types.
types())
463 std::vector<std::pair<t_string, t_string>> specials = atk.special_tooltips();
464 for ( std::size_t
i = 0;
i != specials.size(); ++
i )
466 special_description.emplace(specials[
i].first, specials[
i].second);
468 if (!
type.hide_help()) {
470 std::string type_name =
type.type_name();
472 const std::string section_prefix =
type.show_variations_in_help() ?
".." :
"";
476 std::string link =
make_link(type_name, ref_id);
477 special_units[specials[
i].first].insert(link);
482 for(
config adv :
type.modification_advancements()) {
484 if(effect[
"apply_to"] ==
"new_attack" && effect.has_child(
"specials")) {
485 for(
config::any_child spec : effect.mandatory_child(
"specials").all_children_range()) {
486 if(!spec.cfg[
"name"].empty()) {
487 special_description.emplace(spec.cfg[
"name"].t_str(), spec.cfg[
"description"].t_str());
488 if(!
type.hide_help()) {
490 std::string type_name =
type.type_name();
492 const std::string section_prefix =
type.show_variations_in_help() ?
".." :
"";
496 std::string link =
make_link(type_name, ref_id);
497 special_units[spec.cfg[
"name"]].insert(link);
501 }
else if(effect[
"apply_to"] ==
"attack" && effect.has_child(
"set_specials")) {
502 for(
config::any_child spec : effect.mandatory_child(
"set_specials").all_children_range()) {
503 if(!spec.cfg[
"name"].empty()) {
504 special_description.emplace(spec.cfg[
"name"].t_str(), spec.cfg[
"description"].t_str());
505 if(!
type.hide_help()) {
507 std::string type_name =
type.type_name();
509 const std::string section_prefix =
type.show_variations_in_help() ?
".." :
"";
513 std::string link =
make_link(type_name, ref_id);
514 special_units[spec.cfg[
"name"]].insert(link);
524 s != special_description.end(); ++
s) {
526 std::string
id =
"weaponspecial_" +
s->first.base_str();
527 std::stringstream text;
529 text <<
"\n\n" <<
_(
"<header>text='Units with this special attack'</header>") <<
"\n";
530 std::set<std::string, string_less> &units = special_units[
s->first];
535 topics.emplace_back(
s->first,
id, text.str());
539 std::sort(topics.begin(), topics.end(),
title_less());
545 std::vector<topic> topics;
547 std::map<std::string, const unit_type::ability_metadata*> ability_topic_data;
548 std::map<std::string, std::set<std::string, string_less>> ability_units;
555 const std::string topic_ref = ability.id + ability.name.base_str();
557 ability_topic_data.emplace(topic_ref, &ability);
559 if(!
type.hide_help()) {
564 ability_units[topic_ref].insert(link);
579 parse(
type, ability);
583 parse(
type, ability);
587 for(
const auto&
a : ability_topic_data) {
588 if (
a.second->name.empty()) {
591 std::ostringstream text;
592 text <<
a.second->description;
593 text <<
"\n\n" <<
_(
"<header>text='Units with this ability'</header>") <<
"\n";
595 for(
const auto& u : ability_units[
a.first]) {
603 std::sort(topics.begin(), topics.end(),
title_less());
611 std::vector<topic> topics;
614 if(
era && !
era[
"hide_help"].to_bool()) {
617 std::vector<std::string> faction_links;
618 for (
const topic &
t : topics) {
622 std::stringstream text;
623 text <<
"<header>text='" <<
_(
"Era:") <<
" " <<
era[
"name"] <<
"'</header>" <<
"\n";
626 if (!description.
empty()) {
627 text << description.
t_str() <<
"\n";
631 text <<
"<header>text='" <<
_(
"Factions") <<
"'</header>" <<
"\n";
633 std::sort(faction_links.begin(), faction_links.end());
634 for (
const std::string &link : faction_links) {
640 topics.push_back( era_topic );
647 std::vector<topic> topics;
648 for (
const config &
f :
era.child_range(
"multiplayer_side")) {
649 const std::string&
id =
f[
"id"];
653 std::stringstream text;
656 if (!description.
empty()) {
657 text << description.
t_str() <<
"\n";
661 const std::vector<std::string> recruit_ids =
utils::split(
f[
"recruit"]);
662 std::set<std::string> races;
663 std::set<std::string> alignments;
665 for (
const std::string & u_id : recruit_ids) {
673 alignments.insert(
make_link(
type.alignment_description(
type.alignment(),
type.genders().front()),
"time_of_day"));
677 if (!races.empty()) {
679 text <<
_(
"Races: ") << *(it++);
680 while(it != races.end()) {
681 text <<
", " << *(it++);
686 if (!alignments.empty()) {
688 text <<
_(
"Alignments: ") << *(it++);
689 while(it != alignments.end()) {
690 text <<
", " << *(it++);
695 text <<
"<header>text='" <<
_(
"Leaders") <<
"'</header>" <<
"\n";
696 const std::vector<std::string> leaders =
698 for (
const std::string &link : leaders) {
704 text <<
"<header>text='" <<
_(
"Recruits") <<
"'</header>" <<
"\n";
705 const std::vector<std::string> recruit_links =
707 for (
const std::string &link : recruit_links) {
711 const std::string name =
f[
"name"];
713 topics.emplace_back(name, ref_id, text.str());
716 std::sort(topics.begin(), topics.end(),
title_less());
725 std::map<t_string, const config> trait_list;
729 trait_list.emplace(trait[
"id"], trait);
733 std::set<std::string> races;
744 races.insert(
type.race_id());
754 for (
const config& trait :
type.possible_traits()) {
755 trait_list.emplace(trait[
"id"], trait);
765 for(
const auto& race_id : races) {
767 for(
const config & trait : r->additional_traits()) {
768 trait_list.emplace(trait[
"id"], trait);
773 std::vector<topic> topics;
774 for(
auto&
a : trait_list) {
775 std::string
id =
"traits_" +
a.first;
776 const config& trait =
a.second;
778 std::string name = trait[
"male_name"].str();
779 if (name.empty()) name = trait[
"female_name"].str();
780 if (name.empty()) name = trait[
"name"].str();
781 if (name.empty())
continue;
783 std::stringstream text;
784 if (!trait[
"help_text"].empty()) {
785 text << trait[
"help_text"];
786 }
else if (!trait[
"description"].empty()) {
787 text << trait[
"description"];
789 text <<
_(
"No description available.");
793 topics.emplace_back(name,
id, text.str());
797 std::sort(topics.begin(), topics.end(),
title_less());
808 PLAIN_LOG <<
"Unknown unit type : " << type_id;
812 }
else if (!
type->hide_help()) {
813 std::string name =
type->type_name();
816 const std::string section_prefix =
type->show_variations_in_help() ?
".." :
"";
830 std::vector<std::string> links_list;
831 for (
const std::string &type_id : type_id_list) {
833 if (!unit_link.empty())
834 links_list.push_back(unit_link);
838 std::sort(links_list.begin(), links_list.end());
845 std::set<std::string, string_less> races;
846 std::set<std::string, string_less> visible_races;
853 races.insert(
type.race_id());
854 if(!
type.hide_help())
855 visible_races.insert(
type.race_id());
860 std::set<std::string, string_less> last_sweep = visible_races;
861 while(!last_sweep.empty()) {
862 std::set<std::string, string_less> current_sweep;
863 for(
const auto& race_id : last_sweep) {
865 const auto& help_taxonomy = r->help_taxonomy();
866 if(!help_taxonomy.empty() && !visible_races.count(help_taxonomy) &&
unit_types.
find_race(help_taxonomy)) {
867 current_sweep.insert(help_taxonomy);
868 races.insert(help_taxonomy);
869 visible_races.insert(help_taxonomy);
873 last_sweep = std::move(current_sweep);
876 struct taxonomy_queue_type
878 std::string parent_id;
881 std::vector<taxonomy_queue_type> taxonomy_queue;
885 for(
const auto& race_id : races) {
889 bool hidden = (visible_races.count(race_id) == 0);
894 std::string help_taxonomy;
896 title = r->plural_name();
897 help_taxonomy = r->help_taxonomy();
899 title =
_(
"race^Miscellaneous");
902 section_cfg[
"title"] = title;
904 section_cfg[
"sections_generator"] =
"units:" + race_id;
905 section_cfg[
"generator"] =
"units:" + race_id;
909 if(help_taxonomy.empty()) {
912 bool parent_hidden = (visible_races.count(help_taxonomy) == 0);
914 taxonomy_queue.push_back({std::move(parent_id), std::move(race_section)});
919 bool process_queue_again =
true;
920 while(process_queue_again && !taxonomy_queue.empty()) {
921 process_queue_again =
false;
922 std::vector<taxonomy_queue_type> to_process = std::move(taxonomy_queue);
924 for(
auto& x : to_process) {
927 parent->add_section(std::move(x.content));
928 process_queue_again =
true;
930 taxonomy_queue.push_back(std::move(x));
936 for(
auto& x : taxonomy_queue) {
944 if (
era[
"hide_help"].to_bool()) {
948 DBG_HP <<
"Adding help section: " <<
era[
"id"].str();
953 section_cfg[
"title"] =
era[
"name"];
955 section_cfg[
"generator"] =
"era:" +
era[
"id"].str();
969 WRN_HP <<
"When building terrain help sections, couldn't acquire terrain types data, aborting.";
973 std::map<std::string, section> base_map;
981 bool hidden =
info.hide_help();
988 terrain_topic.
title =
info.editor_name();
990 terrain_topic.
text = std::make_shared<terrain_topic_generator>(
info);
995 const terrain_type& base_info = tdata->get_terrain_info(base);
1000 section& base_section = base_map[base_info.
id()];
1005 if (base_info.
id() ==
info.id())
1007 base_section.
topics.push_back(terrain_topic);
1011 for (
const auto& base : base_map) {
1018 for (
const unit_type_data::unit_type_map::value_type &
i :
unit_types.
types()) {
1021 if (
type.race_id() != race)
1024 if (!
type.show_variations_in_help())
1028 for (
const std::string &variation_id :
type.variations()) {
1030 const unit_type &var_type =
type.get_variation(variation_id);
1034 topic var_topic(topic_name, var_ref,
"");
1035 var_topic.
text = std::make_shared<unit_topic_generator>(var_type, variation_id);
1036 base_unit.
topics.push_back(var_topic);
1039 const std::string type_name =
type.type_name();
1042 base_unit.
id = ref_id;
1043 base_unit.
title = type_name;
1051 std::vector<topic> topics;
1052 std::set<std::string, string_less> race_units;
1053 std::set<std::string, string_less> race_topics;
1054 std::set<std::string> alignments;
1056 for (
const unit_type_data::unit_type_map::value_type &
i :
unit_types.
types())
1060 if (
type.race_id() != race)
1068 const std::string type_name =
type.type_name() + (
type.id() ==
type.type_name().str() ?
"" : debug_suffix);
1069 const std::string real_prefix =
type.show_variations_in_help() ?
".." :
"";
1071 topic unit_topic(type_name, ref_id,
"");
1072 unit_topic.
text = std::make_shared<unit_topic_generator>(
type);
1073 topics.push_back(unit_topic);
1075 if (!
type.hide_help()) {
1078 std::string link =
make_link(type_name, ref_id);
1079 race_units.insert(link);
1081 alignments.insert(
make_link(
type.alignment_description(
type.alignment(),
type.genders().front()),
"time_of_day"));
1086 std::string race_id =
"..race_"+race;
1087 std::string race_name;
1088 std::string race_description;
1089 std::string race_help_taxonomy;
1091 race_name = r->plural_name();
1092 race_description = r->description();
1093 race_help_taxonomy = r->help_taxonomy();
1095 for (
const config &additional_topic : r->additional_topics())
1097 std::string
id = additional_topic[
"id"];
1098 std::string title = additional_topic[
"title"];
1099 std::string text = additional_topic[
"text"];
1101 topics.emplace_back(title,
id,text);
1102 std::string link =
make_link(title,
id);
1103 race_topics.insert(link);
1106 race_name =
_ (
"race^Miscellaneous");
1111 std::map<std::string, t_string> subgroups;
1113 if (r.second.help_taxonomy() == race) {
1114 if (!r.second.plural_name().empty())
1115 subgroups[r.first] = r.second.plural_name();
1117 subgroups[r.first] = r.first;
1121 std::stringstream text;
1123 if (!race_description.empty()) {
1124 text << race_description <<
"\n\n";
1127 if (!alignments.empty()) {
1129 text << (alignments.size() > 1 ?
_(
"Alignments: ") :
_(
"Alignment: ")) << *(it++);
1130 while(it != alignments.end()) {
1131 text <<
", " << *(it++);
1136 if (!race_help_taxonomy.empty()) {
1138 symbols[
"topic_id"] =
"..race_"+race_help_taxonomy;
1140 symbols[
"help_taxonomy"] = r->plural_name();
1144 symbols[
"help_taxonomy"] = race_help_taxonomy;
1148 text <<
VGETTEXT(
"This is a group of units, all of whom are <ref>dst='$topic_id' text='$help_taxonomy'</ref>.", symbols) <<
"\n\n";
1151 if (!subgroups.empty()) {
1152 if (!race_help_taxonomy.empty()) {
1153 text <<
_(
"<header>text='Subgroups of units within this group'</header>") <<
"\n";
1155 text <<
_(
"<header>text='Groups of units within this race'</header>") <<
"\n";
1157 for (
const auto &sg : subgroups) {
1163 if (!race_help_taxonomy.empty()) {
1164 text <<
_(
"<header>text='Units of this group'</header>") <<
"\n";
1166 text <<
_(
"<header>text='Units of this race'</header>") <<
"\n";
1168 for (
const auto &u : race_units) {
1172 topics.emplace_back(race_name, race_id, text.str());
1175 std::sort(topics.begin(), topics.end(),
title_less());
1193 if (
type.id() ==
"Fog Clearer") {
1202 auto section_cfg = help_cfg->
find_child(
"section",
"id", section_name);
1204 return std::string();
1207 std::ostringstream res;
1212 typedef std::pair<std::string,std::string> link;
1213 std::vector<link> topics_links;
1217 for (
t = topics.begin();
t != topics.end(); ++
t) {
1218 if (
auto topic_cfg = help_cfg->
find_child(
"topic",
"id", *
t)) {
1219 std::string
id = topic_cfg[
"id"];
1221 topics_links.emplace_back(topic_cfg[
"title"],
id);
1225 if (section_cfg[
"sort_topics"] ==
"yes") {
1226 std::sort(topics_links.begin(),topics_links.end());
1230 for (l = topics_links.begin(); l != topics_links.end(); ++l) {
1231 std::string link =
make_link(l->first, l->second);
1240 std::stringstream res;
1249 for (
auto &
t : topics) {
1270 return sec.
id ==
id;
1291 topic_list::const_iterator tit =
1293 if (tit != sec.
topics.end()) {
1312 for (
const auto &subsection : sec.
sections) {
1328 std::vector<std::string> res;
1329 bool last_char_escape =
false;
1330 const char escape_char =
'\\';
1331 std::stringstream ss;
1334 for (pos = 0; pos < text.size(); ++pos) {
1335 const char c = text[pos];
1336 if (
c == escape_char && !last_char_escape) {
1337 last_char_escape =
true;
1340 if (state ==
OTHER) {
1342 if (last_char_escape) {
1346 res.push_back(ss.str());
1348 state = ELEMENT_NAME;
1355 else if (state == ELEMENT_NAME) {
1357 std::string
msg =
"Erroneous / in element name.";
1360 else if (
c ==
'>') {
1362 std::stringstream
s;
1363 const std::string element_name = ss.str();
1365 s <<
"</" << element_name <<
">";
1366 const std::string end_element_name =
s.str();
1367 std::size_t end_pos = text.find(end_element_name, pos);
1368 if (end_pos == std::string::npos) {
1369 std::stringstream
msg;
1370 msg <<
"Unterminated element: " << element_name;
1374 const std::string contents = text.substr(pos + 1, end_pos - pos - 1);
1375 const std::string element =
convert_to_wml(element_name, contents);
1376 res.push_back(element);
1377 pos = end_pos + end_element_name.size() - 1;
1384 last_char_escape =
false;
1387 if (state == ELEMENT_NAME) {
1388 std::stringstream
msg;
1389 msg <<
"Element '" << ss.str() <<
"' continues through end of string.";
1392 if (!ss.str().empty()) {
1394 res.push_back(ss.str());
1399 std::string
convert_to_wml(
const std::string &element_name,
const std::string &contents)
1401 std::stringstream ss;
1402 bool in_quotes =
false;
1403 bool last_char_escape =
false;
1404 const char escape_char =
'\\';
1405 std::vector<std::string> attributes;
1410 for (std::size_t pos = 0; pos < contents.size(); ++pos) {
1411 const char c = contents[pos];
1412 if (
c == escape_char && !last_char_escape) {
1413 last_char_escape =
true;
1416 if (
c ==
'\'' && !last_char_escape) {
1418 in_quotes = !in_quotes;
1420 else if ((
c ==
' ' ||
c ==
'\n') && !last_char_escape && !in_quotes) {
1422 attributes.push_back(ss.str());
1428 last_char_escape =
false;
1432 std::stringstream
msg;
1433 msg <<
"Unterminated single quote after: '" << ss.str() <<
"'";
1436 if (!ss.str().empty()) {
1437 attributes.push_back(ss.str());
1441 ss <<
"[" << element_name <<
"]\n";
1442 for (std::vector<std::string>::const_iterator it = attributes.begin();
1443 it != attributes.end(); ++it) {
1446 ss <<
"[/" << element_name <<
"]\n";
1452 if (cmp_str ==
"green") {
1455 if (cmp_str ==
"red") {
1458 if (cmp_str ==
"black") {
1461 if (cmp_str ==
"yellow") {
1464 if (cmp_str ==
"white") {
1468 if (*cmp_str.c_str() ==
'#' && cmp_str.size() == 7) {
1475 const unsigned width)
1477 std::vector<std::string> res;
1480 res.push_back(first_line);
1481 if(
s.size() > first_line.size()) {
1482 res.push_back(
s.substr(first_line.size()));
1495 if (text.length() > 0 && text[0] ==
' ') {
1496 return text.substr(1);
1503 std::size_t first_word_start =
s.find_first_not_of(
' ');
1504 if (first_word_start == std::string::npos) {
1507 std::size_t first_word_end =
s.find_first_of(
" \n", first_word_start);
1508 if( first_word_end == first_word_start ) {
1510 first_word_end = first_word_start+1;
1514 std::string re =
s.substr(0, first_word_end);
1520 char32_t firstchar = *ch;
1522 re = unicode_cast<std::string>(firstchar);
1542 std::stringstream ss;
1545 const std::string
id =
section[
"id"];
1551 if (!ss.str().empty()) {
1558 hidden_toplevel[
"sections"] = ss.str();
1562 const std::string
id =
topic[
"id"];
1565 if (!ss.str().empty()) {
1572 hidden_toplevel[
"topics"] = ss.str();
1573 config hidden_cfg = *help_config;
1576 hidden_cfg.
add_child(
"toplevel", std::move(hidden_toplevel));
1580 std::stringstream
msg;
1581 msg <<
"Parse error when parsing help text: '" <<
e.message <<
"'";
1589 return (hidden ?
"." :
"");
1593 return (
id.empty() ||
id[0] !=
'.');
1602 if (
id ==
"toplevel") {
1608 if (
id.
compare(0, 8,
"ability_") == 0) {
1611 if (
id.
compare(0, 14,
"weaponspecial_") == 0) {
1614 if (
id ==
"hidden") {
1626 if (surf !=
nullptr) {
1632 void push_tab_pair(std::vector<help::item> &v,
const std::string &
s,
const std::optional<std::string> &
image,
unsigned padding)
1638 padding = (width ? padding : 0);
1640 item.first =
"<img>src='" + *
image +
"'</img>" + (padding ?
jump(padding) :
"") +
s;
1641 item.second += width + padding;
1643 v.emplace_back(
item);
1648 table_spec::const_iterator row_it;
1649 std::vector<std::pair<std::string, unsigned>>::const_iterator col_it;
1650 unsigned int num_cols = 0;
1651 for (row_it = tab.begin(); row_it != tab.end(); ++row_it) {
1652 if (row_it->size() > num_cols) {
1653 num_cols = row_it->size();
1656 std::vector<unsigned int> col_widths(num_cols, 0);
1658 for (row_it = tab.begin(); row_it != tab.end(); ++row_it) {
1659 unsigned int col = 0;
1660 for (col_it = row_it->begin(); col_it != row_it->end(); ++col_it) {
1661 if (col_widths[col] < col_it->second + spacing) {
1662 col_widths[col] = col_it->second + spacing;
1667 std::vector<unsigned int> col_starts(num_cols);
1669 for (
unsigned int i = 0;
i < num_cols; ++
i) {
1670 unsigned int this_col_start = 0;
1671 for (
unsigned int j = 0; j <
i; ++j) {
1672 this_col_start += col_widths[j];
1674 col_starts[
i] = this_col_start;
1676 std::stringstream ss;
1677 for (row_it = tab.begin(); row_it != tab.end(); ++row_it) {
1678 unsigned int col = 0;
1679 for (col_it = row_it->begin(); col_it != row_it->end(); ++col_it) {
1680 ss <<
jump_to(col_starts[col]) << col_it->first;
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)
Euivalent to mandatory_child, but returns an empty optional if the nth child was not found.
config & add_child(config_key_type key)
virtual const gamemap & map() const =0
const display_context & get_disp_context() const
static display * get_singleton()
Returns the display object if a display object exists.
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
const std::shared_ptr< terrain_type_data > & tdata() 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.
const std::vector< std::string > & parsed_text() const
std::shared_ptr< topic_generator > generator_
topic_text & operator=(topic_text &&t)=default
std::vector< std::string > parsed_text_
Generic locator abstracting the location of an image.
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
Thrown by operations encountering invalid UTF-8 data.
static std::string _(const char *str)
std::string id
Text to match against addon_info.tags()
static lg::log_domain log_display("display")
static lg::log_domain log_help("help")
Standard logging facilities (interface).
const color_t YELLOW_COLOR
const color_t BLACK_COLOR
int pango_line_width(const std::string &line, int font_size, font::pango_text::FONT_STYLE font_style=font::pango_text::STYLE_NORMAL)
Determine the width of a line of text given a certain font size.
const color_t BIGMAP_COLOR
const std::string unicode_bullet
std::string pango_word_wrap(const std::string &unwrapped_text, int font_size, int max_width, int max_height, int max_lines, bool)
Uses Pango to word wrap text.
const color_t NORMAL_COLOR
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.
std::string make_link(const std::string &text, const std::string &dst)
void generate_races_sections(const config *help_cfg, section &sec, int level)
std::string escape(const std::string &s)
Prepend all chars with meaning inside attributes with a backslash.
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
unsigned image_width(const std::string &filename)
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::vector< help::item > > table_spec
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.
void push_tab_pair(std::vector< help::item > &v, const std::string &s, const std::optional< std::string > &image, unsigned padding)
std::string convert_to_wml(const std::string &element_name, const std::string &contents)
Convert the contents to wml attributes, surrounded within [element_name]...[/element_name].
std::pair< std::string, unsigned > item
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.
std::string generate_table(const table_spec &tab, const unsigned int spacing)
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)
std::string jump_to(const unsigned pos)
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.
std::string generate_topic_text(const std::string &generator, const config *help_cfg, const section &sec, const std::vector< topic > &generated_topics)
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::vector< std::string > split_in_width(const std::string &s, const int font_size, const unsigned width)
Make a best effort to word wrap s.
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.
color_t string_to_color(const std::string &cmp_str)
Return the color the string represents.
std::string jump(const unsigned amount)
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)
std::vector< std::string > parse_text(const std::string &text)
Parse a text string.
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.
surface get_surface(const image::locator &i_locator, TYPE type, bool skip_cache)
Returns an image surface suitable for software manipulation.
bool show_all_units_in_help()
std::set< std::string > & encountered_units()
std::set< t_translation::terrain_code > & encountered_terrains()
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...
std::string escape(const std::string &str, const char *special_chars)
Prepends a configurable set of characters with a backslash.
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="")
Transitional API for porting SDL_ttf-based code to Pango.
The basic class for representing 8-bit RGB or RGBA colour values.
static color_t from_hex_string(const std::string &c)
Creates a new color_t object from a string variable in hex format.
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