The Battle for Wesnoth  1.17.0-dev
unit_preview_pane.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2016 - 2021
3  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 2 of the License, or
8  (at your option) any later version.
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY.
11 
12  See the COPYING file for more details.
13 */
14 
15 #define GETTEXT_DOMAIN "wesnoth-lib"
16 
18 
20 
22 #include "gui/widgets/button.hpp"
23 #include "gui/widgets/image.hpp"
24 #include "gui/widgets/label.hpp"
25 #include "gui/widgets/settings.hpp"
26 #include "gui/widgets/window.hpp"
29 
30 #include "font/text_formatting.hpp"
31 #include "formatter.hpp"
32 #include "formula/string_utils.hpp"
33 #include "language.hpp"
34 #include "preferences/game.hpp"
35 #include "gettext.hpp"
36 #include "help/help.hpp"
37 #include "help/help_impl.hpp"
38 #include "play_controller.hpp"
39 #include "resources.hpp"
40 #include "team.hpp"
41 #include "terrain/movement.hpp"
42 #include "terrain/type_data.hpp"
43 #include "units/attack_type.hpp"
44 #include "units/types.hpp"
45 #include "units/helper.hpp"
46 #include "units/unit.hpp"
47 
48 #include <functional>
49 
50 namespace gui2
51 {
52 
53 // ------------ WIDGET -----------{
54 
55 REGISTER_WIDGET(unit_preview_pane)
56 
57 unit_preview_pane::unit_preview_pane(const implementation::builder_unit_preview_pane& builder)
58  : container_base(builder, type())
59  , current_type_()
60  , icon_type_(nullptr)
61  , icon_race_(nullptr)
62  , icon_alignment_(nullptr)
63  , label_name_(nullptr)
64  , label_level_(nullptr)
65  , label_race_(nullptr)
66  , label_details_(nullptr)
67  , tree_details_(nullptr)
68  , button_profile_(nullptr)
69  , image_mods_()
70 {
71 }
72 
74 {
75  // Icons
76  icon_type_ = find_widget<image>(this, "type_image", false, false);
77  icon_race_ = find_widget<image>(this, "type_race", false, false);
78  icon_alignment_ = find_widget<image>(this, "type_alignment", false, false);
79 
80  // Labels
81  label_name_ = find_widget<label>(this, "type_name", false, false);
82  label_level_ = find_widget<label>(this, "type_level", false, false);
83  label_race_ = find_widget<label>(this, "type_race_label", false, false);
84  label_details_ = find_widget<styled_widget>(this, "type_details_minimal", false, false);
85 
86  tree_details_ = find_widget<tree_view>(this, "type_details", false, false);
87 
88  // Profile button
89  button_profile_ = find_widget<button>(this, "type_profile", false, false);
90 
91  if(button_profile_) {
92  connect_signal_mouse_left_click(*button_profile_,
94  }
95 }
96 
97 static inline tree_view_node& add_name_tree_node(tree_view_node& header_node, const std::string& type, const t_string& label, const t_string& tooltip = "")
98 {
99  /* Note: We have to pass data instead of just doing 'child_label.set_label(label)' below
100  * because the tree_view_node::add_child needs to have the correct size of the
101  * node child widgets for its internal size calculations.
102  * Same is true for 'use_markup'
103  */
104  auto& child_node = header_node.add_child(type, { { "name",{ { "label", label },{ "use_markup", "true" } } } });
105  auto& child_label = find_widget<styled_widget>(&child_node, "name", true);
106 
107  child_label.set_tooltip(tooltip);
108  return child_node;
109 }
110 
111 static inline std::string get_hp_tooltip(const utils::string_map& res, const std::function<int (const std::string&, bool)>& get)
112 {
113  std::ostringstream tooltip;
114 
115  std::set<std::string> resistances_table;
116 
117  bool att_def_diff = false;
118  for(const utils::string_map::value_type &resist : res) {
119  std::ostringstream line;
120  line << translation::dgettext("wesnoth", resist.first.c_str()) << ": ";
121 
122  // Some units have different resistances when attacking or defending.
123  const int res_att = 100 - get(resist.first, true);
124  const int res_def = 100 - get(resist.first, false);
125 
126  if(res_att == res_def) {
127  line << "<span color='" << unit_helper::resistance_color(res_def) << "'>\t" << utils::signed_percent(res_def) << "</span>";
128  } else {
129  line << "<span color='" << unit_helper::resistance_color(res_att) << "'>\t" << utils::signed_percent(res_att) << "</span>" << "/"
130  << "<span color='" << unit_helper::resistance_color(res_def) << "'>" << utils::signed_percent(res_def) << "</span>";
131  att_def_diff = true;
132  }
133 
134  resistances_table.insert(line.str());
135  }
136 
137  tooltip << "<big>" << _("Resistances: ") << "</big>";
138  if(att_def_diff) {
139  tooltip << _("(Att / Def)");
140  }
141 
142  for(const std::string &line : resistances_table) {
143  tooltip << '\n' << font::unicode_bullet << " " << line;
144  }
145 
146  return tooltip.str();
147 }
148 
149 static inline std::string get_mp_tooltip(int total_movement, std::function<int (t_translation::terrain_code)> get)
150 {
151  std::set<terrain_movement> terrain_moves;
152  std::ostringstream tooltip;
153  tooltip << "<big>" << _("Movement Costs:") << "</big>";
154 
155  std::shared_ptr<terrain_type_data> tdata = help::load_terrain_types_data();
156 
157  if(!tdata) {
158  return "";
159  }
160 
163  continue;
164  }
165 
166  const terrain_type& info = tdata->get_terrain_info(terrain);
167  if(info.is_indivisible() && info.is_nonnull()) {
168  terrain_moves.emplace(info.name(), get(terrain));
169  }
170  }
171 
172  for(const terrain_movement& tm: terrain_moves)
173  {
174  tooltip << '\n' << font::unicode_bullet << " " << tm.name << ": ";
175 
176  // movement - range: 1 .. 5, movetype::UNREACHABLE=impassable
177  const bool cannot_move = tm.moves > total_movement;
178 
179  std::string color;
180  if(cannot_move) {
181  // cannot move in this terrain
182  color = "red";
183  } else if(tm.moves > 1) {
184  color = "yellow";
185  } else {
186  color = "white";
187  }
188 
189  tooltip << "<span color='" << color << "'>";
190 
191  // A 5 MP margin; if the movement costs go above the unit's max moves + 5, we replace it with dashes.
192  if(cannot_move && (tm.moves > total_movement + 5)) {
193  tooltip << font::unicode_figure_dash;
194  } else {
195  tooltip << tm.moves;
196  }
197 
198  tooltip << "</span>";
199  }
200 
201  return tooltip.str();
202 }
203 
204 /*
205  * Both unit and unit_type use the same format (vector of attack_types) for their
206  * attack data, meaning we can keep this as a helper function.
207  */
208 template<typename T>
210 {
211  if(attacks.empty()) {
212  return;
213  }
214 
215  auto& header_node = add_name_tree_node(
216  parent_node,
217  "header",
218  "<b>" + _("Attacks") + "</b>"
219  );
220 
221  for(const auto& a : attacks) {
222  const std::string range_png = std::string("icons/profiles/") + a.range() + "_attack.png~SCALE_INTO_SHARP(16,16)";
223  const std::string type_png = std::string("icons/profiles/") + a.type() + ".png~SCALE_INTO_SHARP(16,16)";
224  const bool range_png_exists = ::image::locator(range_png).file_exists();
225  const bool type_png_exists = ::image::locator(type_png).file_exists();
226 
227  const t_string& range = string_table["range_" + a.range()];
228  const t_string& type = string_table["type_" + a.type()];
229 
230  const std::string label = (formatter()
232  << a.damage() << font::weapon_numbers_sep << a.num_attacks()
233  << " " << a.name() << "</span>").str();
234 
235  auto& subsection = header_node.add_child(
236  "item_image",
237  {
238  { "image_range", { { "label", range_png } } },
239  { "image_type", { { "label", type_png } } },
240  { "name", { { "label", label }, { "use_markup", "true" } } },
241  }
242  );
243 
244  find_widget<styled_widget>(&subsection, "image_range", true).set_tooltip(range);
245  find_widget<styled_widget>(&subsection, "image_type", true).set_tooltip(type);
246 
247  if(!range_png_exists || !type_png_exists) {
249  subsection,
250  "item",
251  (formatter()
253  << range << font::weapon_details_sep
254  << type << "</span>"
255  ).str()
256  );
257  }
258 
259  for(const auto& pair : a.special_tooltips()) {
261  subsection,
262  "item",
263  (formatter() << font::span_color(font::weapon_details_color) << pair.first << "</span>").str(),
264  (formatter() << "<span size='x-large'>" << pair.first << "</span>" << "\n" << pair.second).str()
265  );
266  }
267  }
268 }
269 
271 {
272  // Sets the current type id for the profile button callback to use
274 
275  if(icon_type_) {
276  std::string mods;
277 
279  mods = "~RC(" + type.flag_rgb() + ">" +
281  + ")";
282  }
283 
284  mods += "~XBRZ(2)~SCALE_INTO_SHARP(144,144)" + image_mods_;
285 
286  icon_type_->set_label((type.icon().empty() ? type.image() : type.icon()) + mods);
287  }
288 
289  if(label_name_) {
290  label_name_->set_label("<big>" + type.type_name() + "</big>");
292  }
293 
294  if(label_level_) {
295  std::string l_str = VGETTEXT("Lvl $lvl", {{"lvl", std::to_string(type.level())}});
296 
297  label_level_->set_label("<b>" + l_str + "</b>");
300  }
301 
302  if(label_race_) {
303  label_race_ ->set_label(type.race()->name(type.genders().front()));
304  }
305 
306  if(icon_race_) {
307  icon_race_->set_label(type.race()->get_icon_path_stem() + "_30.png");
308  }
309 
310  if(icon_alignment_) {
311  const std::string& alignment_name = type.alignment().to_string();
312 
313  icon_alignment_->set_label("icons/alignments/alignment_" + alignment_name + "_30.png");
315  type.alignment(),
316  type.genders().front()));
317  }
318 
319  if(label_details_) {
320  std::stringstream str;
321 
322  str << "<span size='large'> </span>" << "\n";
323 
324  str << font::span_color(font::unit_type_color) << type.type_name() << "</span>" << "\n";
325 
326  std::string l_str = VGETTEXT("Lvl $lvl", {{"lvl", std::to_string(type.level())}});
327  str << l_str << "\n";
328 
329  str << type.alignment() << "\n";
330 
331  str << "\n"; // Leave a blank line where traits would be
332 
333  str << _("HP: ") << type.hitpoints() << "\n";
334 
335  str << _("XP: ") << type.experience_needed(true);
336 
337  label_details_->set_label(str.str());
339  }
340 
341  if(tree_details_) {
342 
343  tree_details_->clear();
344  tree_details_->add_node("hp_xp_mp", {
345  { "hp",{
346  { "label", (formatter() << "<small>" << font::span_color(unit::hp_color_max()) << "<b>" << _("HP: ") << "</b>" << type.hitpoints() << "</span>" << " | </small>").str() },
347  { "use_markup", "true" },
348  { "tooltip", get_hp_tooltip(type.movement_type().get_resistances().damage_table(), [&type](const std::string& dt, bool is_attacker) { return type.resistance_against(dt, is_attacker); }) }
349  } },
350  { "xp",{
351  { "label", (formatter() << "<small>" << font::span_color(unit::xp_color(100, type.can_advance(), true)) << "<b>" << _("XP: ") << "</b>" << type.experience_needed() << "</span>" << " | </small>").str() },
352  { "use_markup", "true" },
353  { "tooltip", (formatter() << _("Experience Modifier: ") << unit_experience_accelerator::get_acceleration() << '%').str() }
354  } },
355  { "mp",{
356  { "label", (formatter() << "<small>" << "<b>" << _("MP: ") << "</b>" << type.movement() << "</small>").str() },
357  { "use_markup", "true" },
358  { "tooltip", get_mp_tooltip(type.movement(), [&type](t_translation::terrain_code terrain) { return type.movement_type().movement_cost(terrain); }) }
359  } },
360  });
361 
362  // Print trait details
363  {
364  tree_view_node* header_node = nullptr;
365 
366  for(const auto& tr : type.possible_traits()) {
367  t_string name = tr[type.genders().front() == unit_race::FEMALE ? "female_name" : "male_name"];
368  if(tr["availability"] != "musthave" || name.empty()) {
369  continue;
370  }
371 
372  if(header_node == nullptr) {
373  header_node = &add_name_tree_node(
375  "header",
376  "<b>" + _("Traits") + "</b>"
377  );
378  }
379 
381  *header_node,
382  "item",
383  name
384  );
385  }
386  }
387 
388  // Print ability details
389  if(!type.abilities_metadata().empty()) {
390 
391  auto& header_node = add_name_tree_node(
393  "header",
394  "<b>" + _("Abilities") + "</b>"
395  );
396 
397  for(const auto& ab : type.abilities_metadata()) {
398  if(!ab.name.empty()) {
400  header_node,
401  "item",
402  ab.name,
403  (formatter() << "<span size='x-large'>" << ab.name << "</span>\n" << ab.description).str()
404  );
405  }
406  }
407  }
408 
410  }
411 }
412 
414 {
415  // Sets the current type id for the profile button callback to use
416  current_type_ = u.type();
417 
418  if(icon_type_) {
419  std::string mods = u.image_mods();
420 
421  if(u.can_recruit()) {
422  mods += "~BLIT(" + unit::leader_crown() + ")";
423  }
424 
425  for(const std::string& overlay : u.overlays()) {
426  mods += "~BLIT(" + overlay + ")";
427  }
428 
429  mods += "~XBRZ(2)~SCALE_INTO_SHARP(144,144)" + image_mods_;
430 
431  icon_type_->set_label(u.absolute_image() + mods);
432  }
433 
434  if(label_name_) {
435  std::string name;
436  if(!u.name().empty()) {
437  name = "<span size='large'>" + u.name() + "</span>" + "\n" + "<small>" + font::span_color(font::unit_type_color) + u.type_name() + "</span></small>";
438  } else {
439  name = "<span size='large'>" + u.type_name() + "</span>\n";
440  }
441 
442  label_name_->set_label(name);
444  }
445 
446  if(label_level_) {
447  std::string l_str = VGETTEXT("Lvl $lvl", {{"lvl", std::to_string(u.level())}});
448 
449  label_level_->set_label("<b>" + l_str + "</b>");
452  }
453 
454  if(label_race_) {
455  label_race_->set_label(u.race()->name(u.gender()));
456  }
457 
458  if(icon_race_) {
459  icon_race_->set_label(u.race()->get_icon_path_stem() + "_30.png");
460  }
461 
462  if(icon_alignment_) {
463  const std::string& alignment_name = u.alignment().to_string();
464 
465  icon_alignment_->set_label("icons/alignments/alignment_" + alignment_name + "_30.png");
467  u.alignment(),
468  u.gender()));
469  }
470 
471  if(label_details_) {
472  std::stringstream str;
473 
474  const std::string name = "<span size='large'>" + (!u.name().empty() ? u.name() : " ") + "</span>";
475  str << name << "\n";
476 
477  str << font::span_color(font::unit_type_color) << u.type_name() << "</span>" << "\n";
478 
479  std::string l_str = VGETTEXT("Lvl $lvl", {{"lvl", std::to_string(u.level())}});
480  str << l_str << "\n";
481 
482  str << unit_type::alignment_description(u.alignment(), u.gender()) << "\n";
483 
484  str << utils::join(u.trait_names(), ", ") << "\n";
485 
486  str << font::span_color(u.hp_color())
487  << _("HP: ") << u.hitpoints() << "/" << u.max_hitpoints() << "</span>" << "\n";
488 
489  str << font::span_color(u.xp_color()) << _("XP: ");
490  if(u.can_advance()) {
491  str << u.experience() << "/" << u.max_experience();
492  } else {
493  str << font::unicode_en_dash;
494  }
495  str << "</span>";
496 
497  label_details_->set_label(str.str());
499  }
500 
501  if(tree_details_) {
502  tree_details_->clear();
503  const std::string unit_xp = u.can_advance() ? (formatter() << u.experience() << "/" << u.max_experience()).str() : font::unicode_en_dash;
504  tree_details_->add_node("hp_xp_mp", {
505  { "hp",{
506  { "label", (formatter() << "<small>" << font::span_color(u.hp_color()) << "<b>" << _("HP: ") << "</b>" << u.hitpoints() << "/" << u.max_hitpoints() << "</span>" << " | </small>").str() },
507  { "use_markup", "true" },
508  { "tooltip", get_hp_tooltip(u.get_base_resistances(), [&u](const std::string& dt, bool is_attacker) { return u.resistance_against(dt, is_attacker, u.get_location()); }) }
509  } },
510  { "xp",{
511  { "label", (formatter() << "<small>" << font::span_color(u.xp_color()) << "<b>" << _("XP: ") << "</b>" << unit_xp << "</span>" << " | </small>").str() },
512  { "use_markup", "true" },
513  { "tooltip", (formatter() << _("Experience Modifier: ") << unit_experience_accelerator::get_acceleration() << '%').str() }
514  } },
515  { "mp",{
516  { "label", (formatter() << "<small>" << "<b>" << _("MP: ") << "</b>" << u.movement_left() << "/" << u.total_movement() << "</small>").str() },
517  { "use_markup", "true" },
518  { "tooltip", get_mp_tooltip(u.total_movement(), [&u](t_translation::terrain_code terrain) { return u.movement_cost(terrain); }) }
519  } },
520  });
521 
522  if(!u.trait_names().empty()) {
523  auto& header_node = add_name_tree_node(
525  "header",
526  "<b>" + _("Traits") + "</b>"
527  );
528 
529  assert(u.trait_names().size() == u.trait_descriptions().size());
530  for (std::size_t i = 0; i < u.trait_names().size(); ++i) {
532  header_node,
533  "item",
534  u.trait_names()[i],
535  u.trait_descriptions()[i]
536  );
537  }
538  }
539 
540  if(!u.get_ability_list().empty()) {
541  auto& header_node = add_name_tree_node(
543  "header",
544  "<b>" + _("Abilities") + "</b>"
545  );
546 
547  for(const auto& ab : u.ability_tooltips()) {
549  header_node,
550  "item",
551  std::get<2>(ab),
552  std::get<3>(ab)
553  );
554  }
555  }
557  }
558 }
559 
561 {
562  if(get_window() && current_type_) {
564  }
565 }
566 
567 void unit_preview_pane::set_image_mods(const std::string& mods)
568 {
569  image_mods_ = mods;
570 }
571 
572 void unit_preview_pane::set_active(const bool /*active*/)
573 {
574  /* DO NOTHING */
575 }
576 
578 {
579  return true;
580 }
581 
583 {
584  return ENABLED;
585 }
586 
587 void unit_preview_pane::set_self_active(const bool /*active*/)
588 {
589  /* DO NOTHING */
590 }
591 
592 // }---------- DEFINITION ---------{
593 
596 {
597  DBG_GUI_P << "Parsing unit preview pane " << id << '\n';
598 
599  load_resolutions<resolution>(cfg);
600 }
601 
603  : resolution_definition(cfg), grid()
604 {
605  state.emplace_back(cfg.child("background"));
606  state.emplace_back(cfg.child("foreground"));
607 
608  const config& child = cfg.child("grid");
609  VALIDATE(child, _("No grid defined."));
610 
611  grid = std::make_shared<builder_grid>(child);
612 }
613 
614 // }---------- BUILDER -----------{
615 
616 namespace implementation
617 {
618 
619 builder_unit_preview_pane::builder_unit_preview_pane(const config& cfg)
620  : builder_styled_widget(cfg)
621  , image_mods_(cfg["image_mods"])
622 {
623 }
624 
626 {
628 
629  DBG_GUI_G << "Window builder: placed unit preview pane '" << id
630  << "' with definition '" << definition << "'.\n";
631 
632  const auto conf = widget->cast_config_to<unit_preview_pane_definition>();
633  assert(conf);
634 
635  widget->init_grid(*conf->grid);
636  widget->finalize_setup();
637  widget->set_image_mods(image_mods_);
638 
639  return widget;
640 }
641 
642 } // namespace implementation
643 
644 // }------------ END --------------
645 
646 } // namespace gui2
play_controller * controller
Definition: resources.cpp:22
Base class of a resolution, contains the common keys for a resolution.
#define DBG_GUI_P
Definition: log.hpp:66
static config unit_xp(const unit *u)
Definition: reports.cpp:516
config & child(config_key_type key, int n=0)
Returns the nth child with the given key, or a reference to an invalid config if there is none...
Definition: config.cpp:402
void set_displayed_type(const unit_type &type)
Displays the stats of a specified unit type.
std::vector< state_definition > state
static int get_acceleration()
Definition: types.cpp:575
resistances & get_resistances()
Definition: movetype.hpp:268
std::map< std::string, t_string > string_map
utils::optional_reference< const unit_type > current_type_
const std::string weapon_details_sep
Definition: constants.cpp:50
This class represents a single unit of a specific type.
Definition: unit.hpp:121
int movement_cost(const t_translation::terrain_code &terrain) const
Get the unit&#39;s movement cost on a particular terrain.
Definition: unit.hpp:1429
std::string join(const T &v, const std::string &s=",")
Generates a new string joining container items in a list.
bool terrain_matches(const terrain_code &src, const terrain_code &dest)
Tests whether a specific terrain matches an expression, for matching rules see above.
unit_race::GENDER gender() const
The gender of this unit.
Definition: unit.hpp:456
logger & info()
Definition: log.cpp:89
#define a
int hitpoints() const
The current number of hitpoints this unit has.
Definition: unit.hpp:490
tree_view_node & get_root_node()
Definition: tree_view.hpp:75
const std::string & flag_rgb() const
Definition: types.cpp:723
This file contains the window object, this object is a top level container which has the event manage...
Base class for all widgets.
Definition: widget.hpp:49
std::string dgettext(const char *domain, const char *msgid)
Definition: gettext.cpp:415
A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separa...
Definition: translation.hpp:50
int experience_needed(bool with_acceleration=true) const
Definition: types.cpp:580
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...
Definition: terrain.hpp:100
int resistance_against(const std::string &damage_name, bool attacker) const
Gets resistance while considering custom WML abilities.
Definition: types.cpp:776
std::string absolute_image() const
The name of the file to game_display (used in menus).
Definition: unit.cpp:2413
styled_widget * label_details_
A label displays a text, the text can be wrapped but no scrollbars are provided.
Definition: label.hpp:57
void profile_button_callback()
Callback for the profile button.
static std::string _(const char *str)
Definition: gettext.hpp:93
utils::string_map get_base_resistances() const
Gets resistances without any abilities applied.
Definition: unit.hpp:1038
std::vector< std::tuple< std::string, t_string, t_string, t_string > > ability_tooltips() const
Gets the names and descriptions of this unit&#39;s abilities.
Definition: abilities.cpp:326
A single unit type that the player may recruit.
Definition: types.hpp:45
const color_t unit_type_color
bool is_nonnull() const
True if this object represents some sentinel values.
Definition: terrain.hpp:129
const t_string & name(GENDER gender=MALE) const
Definition: race.hpp:37
const terrain_code VOID_TERRAIN
VOID_TERRAIN is used for shrouded hexes.
Generic file dialog.
Definition: field-fwd.hpp:23
const unit_type & type() const
This unit&#39;s type, accounting for gender and variation.
Definition: unit.hpp:346
color_t hp_color() const
Color for this unit&#39;s current hitpoints.
Definition: unit.cpp:1082
virtual void set_label(const t_string &label)
void set_displayed_unit(const unit &u)
Displays the stats of a specific unit.
std::string span_color(const color_t &color)
Returns a Pango formatting string using the provided color_t object.
Base container class.
Definition: grid.hpp:31
std::string definition
Parameters for the styled_widget.
static const std::string & leader_crown()
The path to the leader crown overlay.
Definition: unit.cpp:1034
const std::vector< unit_race::GENDER > & genders() const
The returned vector will not be empty, provided this has been built to the HELP_INDEXED status...
Definition: types.hpp:253
void set_tooltip(const t_string &tooltip)
#define VALIDATE(cond, message)
The macro to use for the validation of WML.
const movetype & movement_type() const
Definition: types.hpp:191
This file contains the settings handling of the widget library.
std::shared_ptr< terrain_type_data > load_terrain_types_data()
Load the appropriate terrain types data to use.
Definition: help_impl.cpp:1622
const terrain_code FOGGED
std::ostringstream wrapper.
Definition: formatter.hpp:39
const t_string & type_name() const
The name of the unit in the current language setting.
Definition: types.hpp:141
void connect_signal_mouse_left_click(dispatcher &dispatcher, const signal_function &signal)
Connects a signal handler for a left mouse button click.
Definition: dispatcher.cpp:172
color_t xp_color() const
Color for this unit&#39;s XP.
Definition: unit.cpp:1136
void init_grid(const builder_grid &grid_builder)
Initializes and builds the grid.
const t_string & name() const
Gets this unit&#39;s translatable display name.
Definition: unit.hpp:394
virtual void set_self_active(const bool active) override
See container_base::set_self_active.
virtual unsigned get_state() const override
See styled_widget::get_state.
virtual void set_active(const bool active) override
See styled_widget::set_active.
static tree_view_node & add_name_tree_node(tree_view_node &header_node, const std::string &type, const t_string &label, const t_string &tooltip="")
int max_experience() const
The max number of experience points this unit can have.
Definition: unit.hpp:520
std::set< t_translation::terrain_code > & encountered_terrains()
Definition: game.cpp:935
const std::vector< ability_metadata > & abilities_metadata() const
Definition: types.hpp:221
int level() const
The current level of this unit.
Definition: unit.hpp:550
virtual void set_use_markup(bool use_markup)
const std::vector< t_string > & trait_names() const
Gets the names of the currently registered traits.
Definition: unit.hpp:1072
const std::vector< std::string > & overlays() const
Get the unit&#39;s overlay images.
Definition: unit.hpp:1588
const t_string & type_name() const
Gets the translatable name of this unit&#39;s type.
Definition: unit.hpp:360
static color_t hp_color_max()
Definition: unit.cpp:1092
const std::string unicode_figure_dash
Definition: constants.cpp:45
void show_unit_description(const unit &u)
Definition: help.cpp:75
#define REGISTER_WIDGET(id)
Wrapper for REGISTER_WIDGET3.
Generic locator abstracting the location of an image.
Definition: picture.hpp:60
static std::string get_side_color_id(unsigned side)
Definition: team.cpp:973
const color_t weapon_details_color
std::size_t i
Definition: function.cpp:967
const std::string unicode_en_dash
Definition: constants.cpp:43
int max_hitpoints() const
The max number of hitpoints this unit can have.
Definition: unit.hpp:496
std::shared_ptr< const typename T::resolution > cast_config_to() const
Casts the current resolution definition config to the respective type of a derived widget...
std::string resistance_color(const int resistance)
Definition: helper.cpp:43
window * get_window()
Get the parent window.
Definition: widget.cpp:117
bool can_recruit() const
Whether this unit can recruit other units - ie, are they a leader unit.
Definition: unit.hpp:603
std::string signed_percent(int val)
Convert into a percentage (using the Unicode "−" and +0% convention.
attack_itors attacks()
Gets an iterator over this unit&#39;s attacks.
Definition: unit.hpp:916
const std::string & icon() const
Definition: types.hpp:180
int level() const
Definition: types.hpp:167
static std::string unit_level_tooltip(const int level, const std::vector< std::string > &adv_to_types, const std::vector< config > &adv_to_mods)
Definition: helper.cpp:57
const unit_race * race() const
Gets this unit&#39;s race.
Definition: unit.hpp:484
const std::string unicode_bullet
Definition: constants.cpp:47
#define VGETTEXT(msgid,...)
Handy wrappers around interpolate_variables_into_string and gettext.
void finalize_setup()
Initializes the internal sub-widget pointers.
int hitpoints() const
Definition: types.hpp:164
A generic container base class.
int movement() const
Definition: types.hpp:169
int movement_cost(const t_translation::terrain_code &terrain, bool slowed=false) const
Returns the cost to move through the indicated terrain.
Definition: movetype.hpp:282
const t_string & name() const
Definition: terrain.hpp:48
config::const_child_itors possible_traits() const
Definition: types.hpp:235
const std::string & image() const
Definition: types.hpp:179
bool empty() const
Definition: tstring.hpp:187
const ter_match ALL_OFF_MAP
const std::string weapon_numbers_sep
Definition: constants.cpp:49
const t_string & tooltip() const
int experience() const
The current number of experience points this unit has.
Definition: unit.hpp:514
UNIT_ALIGNMENT alignment() const
The alignment of this unit.
Definition: unit.hpp:466
utils::string_map damage_table() const
Returns a map from attack types to resistances.
Definition: movetype.cpp:729
const map_location & get_location() const
The current map location this unit is at.
Definition: unit.hpp:1346
symbol_table string_table
Definition: language.cpp:65
const unit_race * race() const
Never returns nullptr, but may point to the null race.
Definition: types.hpp:281
bool can_advance() const
Checks whether this unit has any options to advance to.
Definition: unit.hpp:263
void set_image_mods(const std::string &mods)
Sets the facing of the unit image.
Class to show the tips.
Definition: tooltip.cpp:57
static std::string get_hp_tooltip(const utils::string_map &res, const std::function< int(const std::string &, bool)> &get)
static const std::string & type()
Static type getter that does not rely on the widget being constructed.
int total_movement() const
The maximum moves this unit has.
Definition: unit.hpp:1255
void print_attack_details(T attacks, tree_view_node &parent_node)
std::string get_icon_path_stem() const
Gets this race&#39;s icon path without state/size suffix and extension.
Definition: race.cpp:158
std::vector< std::string > get_ability_list() const
Get a list of all abilities by ID.
Definition: abilities.cpp:242
const_attack_itors attacks() const
Definition: types.cpp:546
int resistance_against(const std::string &damage_name, bool attacker, const map_location &loc, const_attack_ptr weapon=nullptr, const_attack_ptr opp_weapon=nullptr) const
The unit&#39;s resistance against a given damage type.
Definition: unit.cpp:1648
bool can_advance() const
Definition: types.hpp:226
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:61
static std::string alignment_description(ALIGNMENT align, unit_race::GENDER gender=unit_race::MALE)
tree_view_node & add_child(const std::string &id, const std::map< std::string, string_map > &data, const int index=-1)
Constructs a new child node.
ALIGNMENT alignment() const
Definition: types.hpp:197
#define DBG_GUI_G
Definition: log.hpp:41
bool file_exists() const
Tests whether the file the locator points at exists.
Definition: picture.cpp:659
int movement_left() const
Gets how far a unit can move, considering the incapacitated flag.
Definition: unit.hpp:1271
std::string image_mods() const
Gets an IPF string containing all IPF image mods.
Definition: unit.cpp:2592
static std::string get_mp_tooltip(int total_movement, std::function< int(t_translation::terrain_code)> get)
Contains the implementation details for lexical_cast and shouldn&#39;t be used directly.
tree_view_node & add_node(const std::string &id, const std::map< std::string, string_map > &data, const int index=-1)
Definition: tree_view.cpp:57
virtual bool get_active() const override
See styled_widget::get_active.
const std::vector< t_string > & trait_descriptions() const
Gets the descriptions of the currently registered traits.
Definition: unit.hpp:1082