16 #define GETTEXT_DOMAIN "wesnoth-help" 43 #define WRN_HP LOG_STREAM(warn, log_help) 44 #define DBG_HP LOG_STREAM(debug, log_help) 65 std::string lang_policy = (best ?
_(
"Best of") :
_(
"Worst of"));
66 std::string color_policy = (best ?
"green":
"red");
68 return "<format>color='" + color_policy +
"' text='" + lang_policy +
"'</format>";
71 typedef t_translation::ter_list::const_iterator
ter_iter;
73 static std::string
print_behavior_description(ter_iter
start, ter_iter end,
const std::shared_ptr<terrain_type_data> & tdata,
bool first_level =
true,
bool begin_best =
true)
76 if (start == end)
return "";
79 std::optional<ter_iter> last_change_pos;
81 bool best = begin_best;
82 for (ter_iter
i = start;
i != end; ++
i) {
91 if (!last_change_pos) {
92 std::vector<std::string>
names;
93 for (ter_iter
i = start;
i != end; ++
i) {
99 if (names.empty())
return "";
100 if (names.size() == 1)
return names.at(0);
103 if (!first_level) ss <<
"( ";
106 for (std::size_t
i = 1;
i < names.size();
i++) {
107 ss <<
", " << names.at(
i);
110 if (!first_level) ss <<
" )";
112 std::vector<std::string>
names;
113 for (ter_iter
i = *last_change_pos+1;
i != end; ++
i) {
124 if (!first_level) ss <<
"( ";
127 for (
const std::string &
s : names) {
130 if (!first_level) ss <<
" )";
136 std::stringstream ss;
138 if (!type_.icon_image().empty())
139 ss <<
"<img>src='images/buttons/icon-base-32.png~RC(magenta>" << type_.id()
140 <<
")~BLIT("<<
"terrain/" << type_.icon_image() <<
"_30.png)" <<
"'</img> ";
142 if (!type_.editor_image().empty())
143 ss <<
"<img>src='" << type_.editor_image() <<
"'</img> ";
145 if (!type_.help_topic_text().empty())
146 ss <<
"\n\n" << type_.help_topic_text().str() <<
"\n";
153 WRN_HP <<
"When building terrain help topics, we couldn't acquire any terrain types data\n";
159 std::vector<std::string> special_notes;
161 if(type_.is_village()) {
162 special_notes.push_back(
_(
"Villages allow any unit stationed therein to heal, or to be cured of poison."));
163 }
else if(type_.gives_healing() > 0) {
164 auto symbols =
utils::string_map{{
"amount", std::to_string(type_.gives_healing())}};
167 auto message =
VNGETTEXT(
"This terrain allows units to be cured of poison, or to heal a single hitpoint.",
168 "This terrain allows units to heal $amount hitpoints, or to be cured of poison, as if stationed in a village.",
169 type_.gives_healing(), symbols);
170 special_notes.push_back(std::move(message));
173 if(type_.is_castle()) {
174 special_notes.push_back(
_(
"This terrain is a castle — units can be recruited onto it from a connected keep."));
176 if(type_.is_keep() && type_.is_castle()) {
178 special_notes.push_back(
_(
"This terrain is a keep — a leader can recruit from this hex onto connected castle hexes."));
179 }
else if(type_.is_keep() && !type_.is_castle()) {
181 special_notes.push_back(
_(
"This unusual keep allows a leader to recruit while standing on it, but does not allow a leader on a connected keep to recruit onto this hex."));
184 if(!special_notes.empty()) {
185 ss <<
"\n" <<
_(
"Special Notes:") <<
'\n';
186 for(
const auto& note : special_notes) {
193 if (!type_.is_indivisible()) {
194 ss <<
"\n" <<
_(
"Base Terrain: ");
197 for (
const auto& underlying_terrain : type_.union_type()) {
198 const terrain_type& base = tdata->get_terrain_info(underlying_terrain);
214 ss <<
"\n" <<
_(
"Movement properties: ");
218 ss <<
"\n" <<
_(
"Defense properties: ");
225 ss <<
"ID: " << type_.id() <<
"\n";
227 ss <<
"Village: " << (type_.is_village() ?
"Yes" :
"No") <<
"\n";
228 ss <<
"Gives Healing: " << type_.gives_healing() <<
"\n";
230 ss <<
"Keep: " << (type_.is_keep() ?
"Yes" :
"No") <<
"\n";
231 ss <<
"Castle: " << (type_.is_castle() ?
"Yes" :
"No") <<
"\n";
233 ss <<
"Overlay: " << (type_.is_overlay() ?
"Yes" :
"No") <<
"\n";
234 ss <<
"Combined: " << (type_.is_combined() ?
"Yes" :
"No") <<
"\n";
235 ss <<
"Nonnull: " << (type_.is_nonnull() ?
"Yes" :
"No") <<
"\n";
237 ss <<
"Terrain string:" << type_.number() <<
"\n";
239 ss <<
"Hide in Editor: " << (type_.hide_in_editor() ?
"Yes" :
"No") <<
"\n";
240 ss <<
"Editor Group: " << type_.editor_group() <<
"\n";
242 ss <<
"Light Bonus: " << type_.light_bonus(0) <<
"\n";
244 ss << type_.income_description();
246 if (type_.editor_image().empty()) {
247 ss <<
"\nEditor Image: Empty\n";
249 ss <<
"\nEditor Image: " << type_.editor_image() <<
"\n";
253 ss <<
"\nDebug Mvt Description String:";
259 ss <<
"\nDebug Def Description String:";
278 ss <<
make_link(l[i].first, l[i].second);
281 for(i++; i < l.size(); i++) {
282 ss <<
", " <<
make_link(l[i].first,l[i].second);
290 std::stringstream ss;
291 std::string clear_stringstream;
292 const std::string detailed_description = type_.unit_description();
298 ss <<
_(
"Level") <<
" " << type_.level();
301 ss <<
"<img>src='" << male_type.
image();
302 ss <<
"~RC(" << male_type.
flag_rgb() <<
">red)";
303 if (screen_width >= 1200) ss <<
"~XBRZ(2)";
304 ss <<
"' box='no'</img> ";
307 if (&female_type != &male_type) {
308 ss <<
"<img>src='" << female_type.
image();
309 ss <<
"~RC(" << female_type.
flag_rgb() <<
">red)";
310 if (screen_width >= 1200) ss <<
"~XBRZ(2)";
311 ss <<
"' box='no'</img> ";
314 const std::string &male_portrait = male_type.
small_profile().empty() ?
316 const std::string &female_portrait = female_type.
small_profile().empty() ?
319 const bool has_male_portrait = !male_portrait.empty() && male_portrait != male_type.
image() && male_portrait !=
"unit_image";
320 const bool has_female_portrait = !female_portrait.empty() && female_portrait != male_portrait && female_portrait != female_type.
image() && female_portrait !=
"unit_image";
322 int sz = (has_male_portrait && has_female_portrait ? 300 : 400);
323 if (screen_width <= 1366) {
324 sz = (has_male_portrait && has_female_portrait ? 200 : 300);
325 }
else if (screen_width >= 1920) {
330 if (has_male_portrait) {
331 ss <<
"<img>src='" << male_portrait <<
"~FL(horiz)~SCALE_INTO(" << sz <<
',' << sz <<
")' box='no' align='right' float='yes'</img> ";
335 if (has_female_portrait) {
336 ss <<
"<img>src='" << female_portrait <<
"~FL(horiz)~SCALE_INTO(" << sz <<
',' << sz <<
")' box='no' align='right' float='yes'</img> ";
343 const bool first_reverse_value =
true;
344 bool reverse = first_reverse_value;
345 if (variation_.empty()) {
347 std::vector<std::string> adv_units =
348 reverse ? type_.advances_from() : type_.advances_to();
351 for (
const std::string &adv : adv_units) {
359 ss <<
_(
"Advances from: ");
361 ss <<
_(
"Advances to: ");
368 std::string lang_unit = type->
type_name();
384 }
while(reverse != first_reverse_value);
387 const unit_type* parent = variation_.empty() ? &type_ :
389 if (!variation_.empty()) {
393 for (
const std::string& base_id :
utils::split(type_.get_cfg()[
"base_ids"])) {
395 ss <<
_(
"Base units: ");
405 for (
const std::string &var_id : parent->
variations()) {
413 ss <<
_(
"Variations: ");
434 const std::string race_id = type_.race_id();
435 std::string race_name = type_.race()->plural_name();
436 if (race_name.empty()) {
437 race_name =
_ (
"race^Miscellaneous");
440 ss <<
make_link(race_name,
"..race_" + race_id);
446 std::vector<trait_data> must_have_traits;
447 std::vector<trait_data> random_traits;
448 int must_have_nameless_traits = 0;
450 for(
const config& trait : traits) {
451 const std::string& male_name = trait[
"male_name"].str();
452 const std::string& female_name = trait[
"female_name"].str();
453 std::string trait_name;
454 if (type_.has_gender_variation(
unit_race::MALE) && ! male_name.empty())
455 trait_name = male_name;
457 trait_name = female_name;
458 else if (! trait[
"name"].str().empty())
459 trait_name = trait[
"name"].str();
464 if (lang_trait_name.empty() && trait[
"availability"].str() ==
"musthave") {
465 ++must_have_nameless_traits;
468 const std::string ref_id =
"traits_"+trait[
"id"].str();
469 ((trait[
"availability"].str() ==
"musthave") ? must_have_traits : random_traits).emplace_back(lang_trait_name, ref_id);
472 bool line1 = !must_have_traits.empty();
473 bool line2 = !random_traits.empty() && type_.num_traits() > must_have_traits.size();
476 std::string traits_label =
_(
"Traits");
479 std::stringstream must_have_count;
480 must_have_count <<
" (" << must_have_traits.size() <<
") : ";
481 std::stringstream random_count;
482 random_count <<
" (" << (type_.num_traits() - must_have_traits.size() - must_have_nameless_traits) <<
") : ";
488 ss << must_have_count.str();
490 ss <<
"\n" <<
jump(second_line_whitespace) << random_count.str();
499 ss <<
_(
"Traits") <<
" (" << (type_.num_traits() - must_have_nameless_traits) <<
") : ";
508 if(!type_.abilities_metadata().empty()) {
509 ss <<
_(
"Abilities: ");
513 for(
auto iter = type_.abilities_metadata().begin(); iter != type_.abilities_metadata().end(); ++iter) {
514 const std::string ref_id =
ability_prefix + iter->id + iter->name.base_str();
516 if(iter->name.empty()) {
534 if(!type_.adv_abilities_metadata().empty()) {
535 ss <<
_(
"Ability Upgrades: ");
539 for(
auto iter = type_.adv_abilities_metadata().begin(); iter != type_.adv_abilities_metadata().end(); ++iter) {
540 const std::string ref_id =
ability_prefix + iter->id + iter->name.base_str();
542 if(iter->name.empty()) {
570 if (type_.vision() != type_.movement()) {
576 if (type_.jamming() > 0) {
590 <<
make_link(type_.alignment_description(type_.alignment(), type_.genders().front()),
"time_of_day")
592 if (type_.can_advance() || type_.modification_advancements()) {
596 ss <<
_(
"Required\u00a0XP:") <<
font::nbsp << type_.experience_needed();
600 ss <<
"\n\n" << detailed_description;
601 if(
const auto notes = type_.special_notes(); !notes.empty()) {
602 ss <<
"\n\n" <<
_(
"Special Notes:") <<
'\n';
603 for(
const auto& note : notes) {
609 if (!type_.attacks().empty()) {
611 ss <<
"\n\n<header>text='" <<
escape(
_(
"unit help^Attacks"))
615 std::vector<item> first_row;
617 first_row.push_back(
item(
"", 0));
618 push_header(first_row,
_(
"unit help^Name"));
619 push_header(first_row,
_(
"Strikes"));
620 push_header(first_row,
_(
"Range"));
621 push_header(first_row,
_(
"Type"));
622 push_header(first_row,
_(
"Special"));
623 table.push_back(first_row);
626 std::string lang_weapon = attack.name();
627 std::string lang_type =
string_table[
"type_" + attack.type()];
628 std::vector<item> row;
629 std::stringstream attack_ss;
632 attack_ss <<
"<img>src='" << attack.icon() <<
"'</img>";
633 row.emplace_back(attack_ss.str(),
image_width(attack.icon()));
634 attack_ss.str(clear_stringstream);
641 <<
" " << attack.accuracy_parry_description();
643 attack_ss.str(clear_stringstream);
646 const auto padding = 5;
649 const std::string range_icon =
"icons/profiles/" + attack.range() +
"_attack.png";
650 if (attack.min_range() > 1 || attack.max_range() > 1) {
651 attack_ss << attack.min_range() <<
"-" << attack.max_range() <<
' ';
655 attack_ss.str(clear_stringstream);
658 const std::string type_icon =
"icons/profiles/" + attack.type() +
".png";
663 std::vector<std::pair<t_string, t_string>> specials = attack.special_tooltips();
664 if (!specials.empty()) {
665 std::string lang_special =
"";
666 const std::size_t specials_size = specials.size();
667 for (std::size_t
i = 0;
i != specials_size; ++
i) {
668 const std::string ref_id = std::string(
"weaponspecial_")
669 + specials[
i].first.base_str();
670 lang_special = (specials[
i].first);
671 attack_ss <<
make_link(lang_special, ref_id);
672 if (
i+1 != specials_size) {
678 table.push_back(row);
684 movetype movement_type = type_.movement_type();
686 if (!traits.empty() && type_.num_traits() > 0) {
687 for (
const config &
t : traits) {
688 if (
t[
"availability"].str() ==
"musthave") {
689 for (
const config & effect :
t.child_range(
"effect")) {
690 if (!effect.child(
"filter")
692 movement_type.
merge(effect, effect[
"replace"].to_bool());
700 ss <<
"\n\n<header>text='" <<
escape(
_(
"Resistances"))
703 std::vector<item> first_res_row;
704 push_header(first_res_row,
_(
"Attack Type"));
705 push_header(first_res_row,
_(
"Resistance"));
706 resistance_table.push_back(first_res_row);
708 for(std::pair<std::string, std::string> dam_it : dam_tab) {
709 std::vector<item> row;
710 int resistance = 100;
712 resistance -= std::stoi(dam_it.second);
713 }
catch(std::invalid_argument&) {}
714 std::string resist = std::to_string(resistance) +
'%';
715 const std::size_t pos = resist.find(
'-');
716 if (pos != std::string::npos) {
720 std::string lang_weapon =
string_table[
"type_" + dam_it.first];
722 std::stringstream str;
723 str <<
"<format>color=\"" << color <<
"\" text='"<< resist <<
"'</format>";
724 const std::string markup = str.str();
725 str.str(clear_stringstream);
728 resistance_table.push_back(row);
734 ss <<
"\n\n<header>text='" <<
escape(
_(
"Terrain Modifiers"))
736 std::vector<item> first_row;
738 push_header(first_row,
_(
"Terrain"));
739 push_header(first_row,
_(
"Defense"));
740 push_header(first_row,
_(
"Movement Cost"));
743 if (has_terrain_defense_caps) {
744 push_header(first_row,
_(
"Defense Cap"));
747 const bool has_vision = type_.movement_type().has_vision_data();
749 push_header(first_row,
_(
"Vision Cost"));
751 const bool has_jamming = type_.movement_type().has_jamming_data();
753 push_header(first_row,
_(
"Jamming Cost"));
756 table.push_back(first_row);
758 std::set<terrain_movement_info> terrain_moves;
766 const bool cannot_move = moves > type_.movement();
783 terrain_moves.insert(movement_info);
789 std::vector<item> row;
791 bool high_res =
false;
792 const std::string tc_base = high_res ?
"images/buttons/icon-base-32.png" :
"images/buttons/icon-base-16.png";
793 const std::string terrain_image =
"icons/terrain/terrain_type_" + m.id + (high_res ?
"_30.png" :
".png");
795 const std::string final_image = tc_base +
"~RC(magenta>" + m.id +
")~BLIT(" + terrain_image +
")";
797 row.emplace_back(
"<img>src='" + final_image +
"'</img> " +
805 std::stringstream str;
806 str <<
"<format>color='" << color <<
"' text='"<< m.defense <<
"%'</format>";
807 std::string markup = str.str();
808 str.str(clear_stringstream);
809 str << m.defense <<
"%";
813 str.str(clear_stringstream);
814 bool cannot_move = m.movement_cost > type_.movement();
817 }
else if (m.movement_cost > 1) {
822 str <<
"<format>color=" << color <<
" text='";
825 if(cannot_move && (m.movement_cost > type_.movement() + 5)) {
828 str << m.movement_cost;
832 str.str(clear_stringstream);
833 str << m.movement_cost;
837 if (has_terrain_defense_caps) {
838 str.str(clear_stringstream);
840 str <<
"<format>color='"<< color <<
"' text='" << m.defense <<
"%'</format>";
846 str.str(clear_stringstream);
848 str << m.defense <<
'%';
857 str.str(clear_stringstream);
858 const bool cannot_view = m.vision_cost > type_.vision();
861 }
else if (m.vision_cost > m.movement_cost) {
863 }
else if (m.vision_cost == m.movement_cost) {
868 str <<
"<format>color=" << color <<
" text='";
871 if(cannot_view && (m.vision_cost > type_.vision() + 5)) {
874 str << m.vision_cost;
878 str.str(clear_stringstream);
879 str << m.vision_cost;
885 str.str(clear_stringstream);
886 const bool cannot_jam = m.jamming_cost > type_.jamming();
889 }
else if (m.jamming_cost > m.vision_cost) {
891 }
else if (m.jamming_cost == m.vision_cost) {
896 str <<
"<format>color=" << color <<
" text='";
899 if (cannot_jam && m.jamming_cost > type_.jamming() + 5) {
902 str << m.jamming_cost;
909 table.push_back(row);
914 WRN_HP <<
"When building unit help topics, the display object was null and we couldn't get the terrain info we need.\n";
int defense_modifier(const t_translation::terrain_code &terrain) const
Returns the defensive value of the indicated terrain.
int vision_cost(const t_translation::terrain_code &terrain, bool slowed=false) const
Returns the cost to see through the indicated terrain.
const std::string ability_prefix
bool operator<(const terrain_movement_info &other) const
const std::string unit_prefix
void push_tab_pair(std::vector< help::item > &v, const std::string &s, const std::optional< std::string > &image, unsigned padding)
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.
std::map< std::string, t_string > string_map
static lg::log_domain log_help("help")
const std::string unknown_unit_topic
const std::string & big_profile() const
virtual std::string operator()() const
bool terrain_matches(const terrain_code &src, const terrain_code &dest)
Tests whether a specific terrain matches an expression, for matching rules see above.
const std::string & flag_rgb() const
int get_width() const
Returns the width of the drawing surface in pixels.
A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separa...
unit_type_data unit_types
static bool is_indivisible(t_translation::terrain_code id, const t_translation::ter_list &underlying)
Returns true if a terrain has no underlying types other than itself, in respect of either union...
static CVideo & get_singleton()
const int normal_font_size
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...
The basic "size" of the unit - flying, small land, large land, etc.
bool capped(const t_translation::terrain_code &terrain) const
Returns whether there is a defense cap associated to this terrain.
unsigned image_width(const std::string &filename)
static std::string _(const char *str)
const std::string terrain_prefix
int jamming_cost(const t_translation::terrain_code &terrain, bool slowed=false) const
Returns the cost to "jam" through the indicated terrain.
std::string bold(const std::string &s)
A single unit type that the player may recruit.
bool is_nonnull() const
True if this object represents some sentinel values.
const terrain_code VOID_TERRAIN
VOID_TERRAIN is used for shrouded hexes.
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.
static std::string best_str(bool best)
const t_string & editor_name() const
const std::string unicode_minus
std::string generate_table(const table_spec &tab, const unsigned int spacing)
std::vector< std::vector< help::item > > table_spec
std::shared_ptr< terrain_type_data > load_terrain_types_data()
Load the appropriate terrain types data to use.
const terrain_code FOGGED
EXIT_STATUS start(const std::string &filename, bool take_screenshot, const std::string &screenshot_filename)
Main interface for launching the editor from the title screen.
bool hide_if_impassable() const
const t_string & type_name() const
The name of the unit in the current language setting.
terrain_defense & get_defense()
static const std::set< std::string > effects
The set of applicable effects for movement types.
virtual std::string operator()() const
void push_header(std::vector< help::item > &row, const std::string &name) const
std::set< t_translation::terrain_code > & encountered_terrains()
utils::string_map damage_table() const
Returns a map from attack types to resistances.
t_translation::ter_list::const_iterator ter_iter
const std::string & id() const
The id for this unit_type.
const std::string unicode_figure_dash
boost::iterator_range< const_child_iterator > const_child_itors
static void print_trait_list(std::stringstream &ss, const std::vector< trait_data > &l)
static std::string gettext(const char *str)
const std::string variation_prefix
std::vector< std::string > variations() const
std::string resistance_color(const int resistance)
std::string make_link(const std::string &text, const std::string &dst)
static map_location::DIRECTION s
bool show_variations_in_help() const
Whether the unit type has at least one help-visible variation.
std::vector< std::string > names
std::string to_hex_string() const
Returns the stored color in rrggbb hex format.
unsigned screen_width
The screen resolution and pixel pitch should be available for all widgets since their drawing method ...
const std::string unicode_bullet
const std::string & small_profile() const
std::string escape(const std::string &s)
Prepend all chars with meaning inside attributes with a backslash.
int movement_cost(const t_translation::terrain_code &terrain, bool slowed=false) const
Returns the cost to move through the indicated terrain.
const t_string & name() const
const std::string & image() const
std::string jump(const unsigned amount)
const ter_match ALL_OFF_MAP
const std::string weapon_numbers_sep
const unit_type & get_variation(const std::string &id) const
color_t red_to_green(int val, bool for_text)
Return a color corresponding to the value val red for val=0 to green for val=100, passing by yellow...
std::vector< std::string > split(const config_attribute_value &val)
static std::string print_behavior_description(ter_iter start, ter_iter end, const std::shared_ptr< terrain_type_data > &tdata, bool first_level=true, bool begin_best=true)
int icompare(const std::string &s1, const std::string &s2)
Case-insensitive lexicographical comparison.
symbol_table string_table
const t_string & variation_name() const
Standard logging facilities (interface).
const std::string & id() const
std::vector< terrain_code > ter_list
const unit_type & get_gender_unit_type(std::string gender) const
Returns a gendered variant of this unit_type.
A config object defines a single node in a WML file, with access to child nodes.
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. ...
Transitional API for porting SDL_ttf-based code to Pango.
std::pair< std::string, std::string > trait_data
std::pair< std::string, unsigned > item
bool has_terrain_defense_caps(const std::set< t_translation::terrain_code > &ts) const
Returns whether or not there are any terrain caps with respect to a set of terrains.
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.