The Battle for Wesnoth  1.15.2+dev
unit_recall.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2016 - 2018 by the Battle for Wesnoth Project https://www.wesnoth.org/
3 
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; either version 2 of the License, or
7  (at your option) any later version.
8  This program is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY.
10 
11  See the COPYING file for more details.
12 */
13 
14 #define GETTEXT_DOMAIN "wesnoth-lib"
15 
17 
18 #include "font/text_formatting.hpp"
20 #include "gui/core/log.hpp"
22 #include "gui/dialogs/message.hpp"
23 #include "gui/widgets/listbox.hpp"
24 #include "gui/widgets/settings.hpp"
25 #include "gui/widgets/button.hpp"
26 #include "gui/widgets/image.hpp"
27 #include "gui/widgets/label.hpp"
28 #include "gui/widgets/text_box.hpp"
31 #include "gui/widgets/window.hpp"
32 #include "help/help.hpp"
33 #include "game_board.hpp"
34 #include "gettext.hpp"
35 #include "replay_helper.hpp"
36 #include "play_controller.hpp"
37 #include "resources.hpp"
38 #include "synced_context.hpp"
39 #include "team.hpp"
40 #include "units/types.hpp"
41 #include "units/unit.hpp"
42 #include "units/ptr.hpp"
43 #include "utils/functional.hpp"
44 #include "whiteboard/manager.hpp"
45 
46 #include <boost/dynamic_bitset.hpp>
47 
48 static lg::log_domain log_display("display");
49 #define LOG_DP LOG_STREAM(info, log_display)
50 
51 namespace gui2
52 {
53 namespace dialogs
54 {
55 
56 // Index 2 is by-level
59 
61 
63  : recall_list_(recall_list)
64  , team_(team)
65  , selected_index_()
66  , filter_options_()
67  , last_words_()
68 {
69 }
70 
71 template<typename T>
72 static void dump_recall_list_to_console(const T& units)
73 {
74  log_scope2(log_display, "dump_recall_list_to_console()")
75 
76  LOG_DP << "size: " << units.size() << "\n";
77 
78  std::size_t idx = 0;
79  for(const unit_const_ptr& u_ptr : units) {
80  LOG_DP << "\tunit[" << (idx++) << "]: " << u_ptr->id() << " name = '" << u_ptr->name() << "'\n";
81  }
82 }
83 
84 static const color_t inactive_row_color(0x96, 0x96, 0x96);
85 
86 static const inline std::string maybe_inactive(const std::string& str, bool active)
87 {
88  if(active)
89  return str;
90  else
91  return font::span_color(inactive_row_color, str);
92 }
93 
94 static std::string format_level_string(const int level, bool recallable)
95 {
96  std::string lvl = std::to_string(level);
97 
98  if(!recallable) {
99  // Same logic as when recallable, but always in inactive_row_color.
100  if(level < 2) {
101  return font::span_color(inactive_row_color, lvl);
102  } else {
103  return font::span_color(inactive_row_color, "<b>" + lvl + "</b>");
104  }
105  } else if(level < 1) {
106  return font::span_color(inactive_row_color, lvl);
107  } else if(level == 1) {
108  return lvl;
109  } else if(level == 2) {
110  return "<b>" + lvl + "</b>";
111  } else {
112  return"<b><span color='#ffffff'>" + lvl + "</span></b>";
113  }
114 }
115 
116 static std::string format_cost_string(int unit_recall_cost, const int team_recall_cost)
117 {
118  std::stringstream str;
119 
120  if(unit_recall_cost < 0) {
121  unit_recall_cost = team_recall_cost;
122  }
123 
124  if(unit_recall_cost > team_recall_cost) {
125  str << "<span color='#ff0000'>" << unit_recall_cost << "</span>";
126  } else if(unit_recall_cost == team_recall_cost) {
127  str << unit_recall_cost;
128  } else if(unit_recall_cost < team_recall_cost) {
129  str << "<span color='#00ff00'>" << unit_recall_cost << "</span>";
130  }
131 
132  return str.str();
133 }
134 
135 static std::string get_title_suffix(int side_num)
136 {
137  if(!resources::gameboard) {
138  return "";
139  }
140 
141  unit_map& units = resources::gameboard->units();
142 
143  int controlled_recruiters = 0;
144  for(const auto& team : resources::gameboard->teams()) {
145  if(team.is_local_human() && !team.recruits().empty() && units.find_leader(team.side()) !=units.end()) {
146  ++controlled_recruiters;
147  }
148  }
149 
150  std::stringstream msg;
151  if(controlled_recruiters >= 2) {
153  if(leader != resources::gameboard->units().end() && !leader->name().empty()) {
154  msg << " (" << leader->name(); msg << ")";
155  }
156  }
157 
158  return msg.str();
159 }
160 
162 {
163  label& title = find_widget<label>(&window, "title", true);
164  title.set_label(title.get_label() + get_title_suffix(team_.side()));
165 
166  text_box* filter
167  = find_widget<text_box>(&window, "filter_box", false, true);
168 
170  std::bind(&unit_recall::filter_text_changed, this, _1, _2));
171 
172  listbox& list = find_widget<listbox>(&window, "recall_list", false);
173 
174  connect_signal_notify_modified(list, std::bind(&unit_recall::list_item_clicked, this, std::ref(window)));
175 
176  list.clear();
177 
178  window.keyboard_capture(filter);
179  window.add_to_keyboard_chain(&list);
180 
182  find_widget<button>(&window, "rename", false),
183  std::bind(&unit_recall::rename_unit, this, std::ref(window)));
184 
186  find_widget<button>(&window, "dismiss", false),
187  std::bind(&unit_recall::dismiss_unit, this, std::ref(window)));
188 
190  find_widget<button>(&window, "show_help", false),
191  std::bind(&unit_recall::show_help, this));
192 
193  for(const unit_const_ptr& unit : recall_list_) {
194  std::map<std::string, string_map> row_data;
195  string_map column;
196 
197  std::string mods = unit->image_mods();
198 
199  int wb_gold = 0;
201  if(const std::shared_ptr<wb::manager>& whiteb = resources::controller->get_whiteboard()) {
202  wb::future_map future; // So gold takes into account planned spending
203  wb_gold = whiteb->get_spent_gold_for(team_.side());
204  }
205  }
206 
207  // Note: Our callers apply [filter_recall], but leave it to us
208  // to apply cost-based filtering.
209  const int recall_cost = (unit->recall_cost() > -1 ? unit->recall_cost() : team_.recall_cost());
210  const bool recallable = (recall_cost <= team_.gold() - wb_gold);
211 
212  if(unit->can_recruit()) {
213  mods += "~BLIT(" + unit::leader_crown() + ")";
214  }
215 
216  for(const std::string& overlay : unit->overlays()) {
217  mods += "~BLIT(" + overlay + ")";
218  }
219 
220  if(!recallable) {
221  mods += "~GS()";
222 
223  // Just set the tooltip on every single element in this row.
224  if(wb_gold > 0)
225  column["tooltip"] = _("This unit cannot be recalled because you will not have enough gold at this point in your plan.");
226  else
227  column["tooltip"] = _("This unit cannot be recalled because you do not have enough gold.");
228  }
229 
230  column["use_markup"] = "true";
231 
232  column["label"] = unit->absolute_image() + mods;
233  row_data.emplace("unit_image", column);
234 
235  column["label"] = maybe_inactive(unit->type_name(), recallable);
236  row_data.emplace("unit_type", column);
237 
238  // gold_icon is handled below
239 
240  column["label"] =
241  recallable
243  : maybe_inactive(std::to_string(recall_cost), recallable);
244  row_data.emplace("unit_recall_cost", column);
245 
246  const std::string& name = !unit->name().empty() ? unit->name().str() : font::unicode_en_dash;
247  column["label"] = maybe_inactive(name, recallable);
248  row_data.emplace("unit_name", column);
249 
250  column["label"] = format_level_string(unit->level(), recallable);
251  row_data.emplace("unit_level", column);
252 
253  std::stringstream exp_str;
254  if(unit->can_advance()) {
255  exp_str << unit->experience() << "/" << unit->max_experience();
256  } else {
257  exp_str << font::unicode_en_dash;
258  }
259 
260  column["label"] = font::span_color(recallable ? unit->xp_color() : inactive_row_color, exp_str.str());
261  row_data.emplace("unit_experience", column);
262 
263  // Since the table widgets use heavy formatting, we save a bare copy
264  // of certain options to filter on.
265  std::string filter_text = unit->type_name() + " " + name + " " + std::to_string(unit->level());
266 
267  if(recallable) {
268  // This is to allow filtering for recallable units by typing "vvv" in the search box.
269  // That's intended to be easy to type and unlikely to match unit or type names.
270  //
271  // TODO: document this. (Also, implement a "Hide non-recallable units" checkbox.)
272  filter_text += " " + std::string("vvv");
273  }
274 
275  std::string traits;
276  for(const std::string& trait : unit->trait_names()) {
277  traits += (traits.empty() ? "" : "\n") + trait;
278  filter_text += " " + trait;
279  }
280 
281  column["label"] = maybe_inactive(
282  !traits.empty() ? traits : font::unicode_en_dash,
283  recallable);
284  row_data.emplace("unit_traits", column);
285 
286  filter_options_.push_back(filter_text);
287  grid& grid = list.add_row(row_data);
288  if(!recallable) {
289  image *gold_icon = dynamic_cast<image*>(grid.find("gold_icon", false));
290  assert(gold_icon);
291  gold_icon->set_image(gold_icon->get_image() + "~GS()");
292  }
293  }
294 
295  list.register_translatable_sorting_option(0, [this](const int i) { return recall_list_[i]->type_name().str(); });
296  list.register_translatable_sorting_option(1, [this](const int i) { return recall_list_[i]->name().str(); });
297  list.register_sorting_option(2, [this](const int i) {
298  const unit& u = *recall_list_[i];
299  return std::make_tuple(u.level(), -static_cast<int>(u.experience_to_advance()));
300  });
301  list.register_sorting_option(3, [this](const int i) { return recall_list_[i]->experience(); });
302  list.register_translatable_sorting_option(4, [this](const int i) {
303  return !recall_list_[i]->trait_names().empty() ? recall_list_[i]->trait_names().front().str() : "";
304  });
305 
306  list.set_active_sorting_option(sort_last.first >= 0 ? sort_last : sort_default, true);
307 
308  list_item_clicked(window);
309 }
310 
312 {
313  listbox& list = find_widget<listbox>(&window, "recall_list", false);
314 
315  const int index = list.get_selected_row();
316  unit& selected_unit = const_cast<unit&>(*recall_list_[index].get());
317 
318  std::string name = selected_unit.name();
319  const std::string dialog_title(_("Rename Unit"));
320  const std::string dialog_label(_("Name:"));
321 
322  if(gui2::dialogs::edit_text::execute(dialog_title, dialog_label, name)) {
323  selected_unit.rename(name);
324 
325  find_widget<label>(list.get_row_grid(index), "unit_name", false).set_label(name);
326 
327  filter_options_.erase(filter_options_.begin() + index);
328  std::ostringstream filter_text;
329  filter_text << selected_unit.type_name() << " " << name << " " << std::to_string(selected_unit.level());
330  for(const std::string& trait : selected_unit.trait_names()) {
331  filter_text << " " << trait;
332  }
333  filter_options_.insert(filter_options_.begin() + index, filter_text.str());
334 
335  list_item_clicked(window);
336  window.invalidate_layout();
337  }
338 }
339 
341 {
342  LOG_DP << "Recall list units:\n"; dump_recall_list_to_console(recall_list_);
343 
344  listbox& list = find_widget<listbox>(&window, "recall_list", false);
345  const int index = list.get_selected_row();
346 
347  const unit& u = *recall_list_[index].get();
348 
349  // If the unit is of level > 1, or is close to advancing, we warn the player about it
350  std::stringstream message;
351  if(u.loyal()) {
352  message << _("This unit is loyal and requires no upkeep.") << " " << (u.gender() == unit_race::MALE
353  ? _("Do you really want to dismiss him?")
354  : _("Do you really want to dismiss her?"));
355 
356  } else if(u.level() > 1) {
357  message << _("This unit is an experienced one, having advanced levels.") << " " << (u.gender() == unit_race::MALE
358  ? _("Do you really want to dismiss him?")
359  : _("Do you really want to dismiss her?"));
360 
361  } else if(u.experience() > u.max_experience()/2) {
362  message << _("This unit is close to advancing a level.") << " " << (u.gender() == unit_race::MALE
363  ? _("Do you really want to dismiss him?")
364  : _("Do you really want to dismiss her?"));
365  }
366 
367  if(!message.str().empty()) {
368  const int res = gui2::show_message(_("Dismiss Unit"), message.str(), message::yes_no_buttons);
369 
370  if(res != gui2::retval::OK) {
371  return;
372  }
373  }
374 
375  recall_list_.erase(recall_list_.begin() + index);
376 
377  // Remove the entry from the dialog list
378  list.remove_row(index);
379  list_item_clicked(window);
380 
381  // Remove the entry from the filter list
382  filter_options_.erase(filter_options_.begin() + index);
383  assert(filter_options_.size() == list.get_item_count());
384 
385  LOG_DP << "Dismissing a unit, side = " << u.side() << ", id = '" << u.id() << "'\n";
386  LOG_DP << "That side's recall list:\n";
388 
389  // Find the unit in the recall list.
390  unit_ptr dismissed_unit = team_.recall_list().find_if_matches_id(u.id());
391  assert(dismissed_unit);
392 
393  // Record the dismissal, then delete the unit.
394  synced_context::run_and_throw("disband", replay_helper::get_disband(dismissed_unit->id()));
395 
396  // Close the dialog if all units are dismissed
397  if(list.get_item_count() == 0) {
398  window.set_retval(retval::CANCEL);
399  }
400 }
401 
403 {
404  help::show_help("recruit_and_recall");
405 }
406 
408 {
409  const int selected_row
410  = find_widget<listbox>(&window, "recall_list", false).get_selected_row();
411 
412  if(selected_row == -1) {
413  return;
414  }
415 
416  const unit& selected_unit = *recall_list_[selected_row].get();
417 
418  find_widget<unit_preview_pane>(&window, "unit_details", false)
419  .set_displayed_unit(selected_unit);
420 
421  find_widget<button>(&window, "rename", false).set_active(!selected_unit.unrenamable());
422 }
423 
425 {
426  listbox& list = find_widget<listbox>(&window, "recall_list", false);
428 
429  if(get_retval() == retval::OK) {
431  }
432 }
433 
434 void unit_recall::filter_text_changed(text_box_base* textbox, const std::string& text)
435 {
436  window& window = *textbox->get_window();
437 
438  listbox& list = find_widget<listbox>(&window, "recall_list", false);
439 
440  const std::vector<std::string> words = utils::split(text, ' ');
441 
442  if(words == last_words_)
443  return;
444  last_words_ = words;
445 
446  boost::dynamic_bitset<> show_items;
447  show_items.resize(list.get_item_count(), true);
448 
449  if(!text.empty()) {
450  for(unsigned int i = 0; i < list.get_item_count(); i++) {
451  bool found = false;
452 
453  for(const auto & word : words) {
454  found = translation::ci_search(filter_options_[i], word);
455 
456  if(!found) {
457  // one word doesn't match, we don't reach words.end()
458  break;
459  }
460  }
461 
462  show_items[i] = found;
463  }
464  }
465 
466  list.set_row_shown(show_items);
467 }
468 
469 } // namespace dialogs
470 } // namespace gui2
const order_pair get_active_sorting_option()
Definition: listbox.cpp:659
Define the common log macros for the gui toolkit.
static const std::string maybe_inactive(const std::string &str, bool active)
Definition: unit_recall.cpp:86
play_controller * controller
Definition: resources.cpp:21
boost::intrusive_ptr< const unit > unit_const_ptr
Definition: ptr.hpp:30
void list_item_clicked(window &window)
Callbacks.
Dialog was closed with the CANCEL button.
Definition: retval.hpp:37
void set_active_sorting_option(const order_pair &sort_by, const bool select_first=false)
Sorts the listbox by a pre-set sorting option.
Definition: listbox.cpp:640
void set_text_changed_callback(std::function< void(text_box_base *textbox, const std::string text)> cb)
Set the text_changed callback.
void show_message(const std::string &title, const std::string &msg, const std::string &button_caption, const bool auto_close, const bool message_use_markup, const bool title_use_markup)
Shows a message to the user.
Definition: message.cpp:152
unit_iterator end()
Definition: map.hpp:415
void show_help(const std::string &show_topic, int xloc, int yloc)
Open the help browser, show topic with id show_topic.
Definition: help.cpp:116
Abstract base class for text items.
virtual const unit_map & units() const override
Definition: game_board.hpp:114
This class represents a single unit of a specific type.
Definition: unit.hpp:99
unit_iterator find_leader(int side)
Definition: map.cpp:329
Main class to show messages to the user.
Definition: message.hpp:34
unit_race::GENDER gender() const
The gender of this unit.
Definition: unit.hpp:426
static const color_t inactive_row_color(0x96, 0x96, 0x96)
void rename(const std::string &name)
Attempts to rename this unit&#39;s translatable display name, taking the &#39;unrenamable&#39; flag into account...
Definition: unit.hpp:388
virtual void post_show(window &window) override
Inherited from modal_dialog.
std::vector< unit_const_ptr > recalls_ptr_vector
Definition: unit_recall.hpp:37
This file contains the window object, this object is a top level container which has the event manage...
t_string get_image() const
Wrapper for label.
Definition: image.hpp:58
static listbox::order_pair sort_default
Definition: unit_recall.cpp:58
void register_translatable_sorting_option(const int col, translatable_sorter_func_t f)
Registers a special sorting function specifically for translatable values.
Definition: listbox.cpp:632
std::string absolute_image() const
The name of the file to game_display (used in menus).
Definition: unit.cpp:2390
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
Label showing a text.
Definition: label.hpp:32
int get_selected_row() const
Returns the first selected row.
Definition: listbox.cpp:272
-file sdl_utils.hpp
std::vector< std::string > split(const std::string &val, const char c, const int flags)
Splits a (comma-)separated string into a vector of pieces.
std::pair< int, SORT_ORDER > order_pair
Definition: listbox.hpp:288
static lg::log_domain log_display("display")
void filter_text_changed(text_box_base *textbox, const std::string &text)
Class for a single line text area.
Definition: text_box.hpp:121
Generic file dialog.
Definition: field-fwd.hpp:22
int gold() const
Definition: team.hpp:189
static listbox::order_pair sort_last
Definition: unit_recall.cpp:57
unsigned int experience_to_advance() const
The number of experience points this unit needs to level up, or 0 if current XP > max XP...
Definition: unit.hpp:502
virtual void set_label(const t_string &label)
The listbox class.
Definition: listbox.hpp:40
static std::string format_level_string(const int level)
Definition: unit_list.cpp:54
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:30
This class stores all the data for a single &#39;side&#39; (in game nomenclature).
Definition: team.hpp:44
static UNUSEDNOWARN std::string _(const char *str)
Definition: gettext.hpp:91
static const std::string & leader_crown()
The path to the leader crown overlay.
Definition: unit.cpp:1074
const std::string & id() const
Gets this unit&#39;s id.
Definition: unit.hpp:344
void connect_signal_notify_modified(dispatcher &dispatcher, const signal_notification_function &signal)
Connects a signal handler for getting a notification upon modification.
Definition: dispatcher.cpp:248
unit_ptr find_if_matches_id(const std::string &unit_id)
Find a unit by id.
std::vector< std::string > filter_options_
Definition: unit_recall.hpp:54
This file contains the settings handling of the widget library.
Applies the planned unit map for the duration of the struct&#39;s life.
Definition: manager.hpp:251
void clear()
Removes all the rows in the listbox, clearing it.
Definition: listbox.cpp:125
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:233
recalls_ptr_vector & recall_list_
Definition: unit_recall.hpp:48
color_t xp_color() const
Color for this unit&#39;s XP.
Definition: unit.cpp:1132
game_board * gameboard
Definition: resources.cpp:20
const t_string & name() const
Gets this unit&#39;s translatable display name.
Definition: unit.hpp:367
int max_experience() const
The max number of experience points this unit can have.
Definition: unit.hpp:490
widget * find(const std::string &id, const bool must_be_active) override
See widget::find.
Definition: grid.cpp:655
unsigned get_item_count() const
Returns the number of items in the listbox.
Definition: listbox.cpp:131
Shows a yes and no button.
Definition: message.hpp:79
int level() const
The current level of this unit.
Definition: unit.hpp:520
#define log_scope2(domain, description)
Definition: log.hpp:187
const std::vector< t_string > & trait_names() const
Gets the names of the currently registered traits.
Definition: unit.hpp:1036
const std::vector< std::string > & overlays() const
Get the unit&#39;s overlay images.
Definition: unit.hpp:1508
#define LOG_DP
Definition: unit_recall.cpp:49
const t_string & type_name() const
Gets the translatable name of this unit&#39;s type.
Definition: unit.hpp:333
static std::string format_cost_string(int unit_recall_cost, const int team_recall_cost)
Various uncategorised dialogs.
int recall_cost() const
Definition: team.hpp:193
bool loyal() const
Gets whether this unit is loyal - ie, it costs no upkeep.
Definition: unit.cpp:1630
virtual void pre_show(window &window) override
Inherited from modal_dialog.
bool ci_search(const std::string &s1, const std::string &s2)
Definition: gettext.cpp:519
std::size_t i
Definition: function.cpp:933
const std::string unicode_en_dash
Definition: constants.cpp:39
void rename_unit(window &window)
window * get_window()
Get the parent window.
Definition: widget.cpp:114
bool can_recruit() const
Whether this unit can recruit other units - ie, are they a leader unit.
Definition: unit.hpp:577
std::map< std::string, t_string > string_map
Definition: widget.hpp:24
grid & add_row(const string_map &item, const int index=-1)
When an item in the list is selected by the user we need to update the state.
Definition: listbox.cpp:66
static std::string get_title_suffix(int side_num)
std::size_t index(const std::string &str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
Definition: unicode.cpp:71
static void dump_recall_list_to_console(const T &units)
Definition: unit_recall.cpp:72
std::vector< std::string > last_words_
Definition: unit_recall.hpp:55
static config get_disband(const std::string &unit_id)
const grid * get_row_grid(const unsigned row) const
Returns the grid of the wanted row.
Definition: listbox.cpp:237
void set_image(const t_string &label)
Wrapper for set_label.
Definition: image.hpp:45
static bool run_and_throw(const std::string &commandname, const config &data, bool use_undo=true, bool show=true, synced_command::error_handler_function error_handler=default_error_function)
const t_string & get_label() const
bool empty() const
Definition: tstring.hpp:182
bool is_local_human() const
Definition: team.hpp:267
boost::intrusive_ptr< unit > unit_ptr
Definition: ptr.hpp:29
int experience() const
The current number of experience points this unit has.
Definition: unit.hpp:484
void dismiss_unit(window &window)
this module manages the cache of images.
bool can_advance() const
Checks whether this unit has any options to advance to.
Definition: unit.hpp:232
recall_list_manager & recall_list()
Definition: team.hpp:215
void remove_row(const unsigned row, unsigned count=1)
Removes a row in the listbox.
Definition: listbox.cpp:86
Container associating units to locations.
Definition: map.hpp:99
int side() const
The side this unit belongs to.
Definition: unit.hpp:304
Dialog was closed with the OK button.
Definition: retval.hpp:34
int side() const
Definition: team.hpp:188
void register_sorting_option(const int col, const Func &f)
Definition: listbox.hpp:269
const std::string & str() const
Definition: tstring.hpp:186
base class of top level items, the only item which needs to store the final canvases to draw on ...
Definition: window.hpp:63
bool unrenamable() const
Whether this unit can be renamed.
Definition: unit.hpp:400
int recall_cost() const
How much gold it costs to recall this unit, or -1 if the side&#39;s default recall cost is used...
Definition: unit.hpp:605
void set_row_shown(const unsigned row, const bool shown)
Makes a row visible or invisible.
Definition: listbox.cpp:143
std::string image_mods() const
Gets an IPF string containing all IPF image mods.
Definition: unit.cpp:2574
const std::set< std::string > & recruits() const
Definition: team.hpp:223