The Battle for Wesnoth  1.19.0+dev
game_stats.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2016 - 2024
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 #include "gui/widgets/listbox.hpp"
21 #include "gui/widgets/label.hpp"
23 #include "gui/widgets/window.hpp"
24 #include "formatter.hpp"
25 #include "game_classification.hpp"
26 #include "map/map.hpp"
27 #include "play_controller.hpp"
28 #include "resources.hpp"
29 #include "units/map.hpp"
30 #include "units/unit.hpp"
31 
32 #include <functional>
33 
34 static lg::log_domain log_display("display");
35 #define LOG_DP LOG_STREAM(info, log_display)
36 
37 namespace gui2::dialogs
38 {
39 
40 REGISTER_DIALOG(game_stats)
41 
42 game_stats::game_stats(const display_context& board, const int viewing_team, int& selected_side_number)
43  : modal_dialog(window_id())
44  , board_(board)
45  , viewing_team_(board_.teams()[viewing_team])
46  , selected_side_number_(selected_side_number)
47 {
48 }
49 
51 {
53 
54  if(leader != board_.units().end()) {
55  return leader.get_shared_ptr();
56  }
57 
58  return nullptr;
59 }
60 
61 static std::string controller_name(const team& t)
62 {
63  static const side_controller::sized_array<t_string> names {_("controller^Idle"), _("controller^Human"), _("controller^AI"), _("controller^Reserved")};
64  return "<span color='#808080'><small>" + names[static_cast<int>(t.controller())] + "</small></span>";
65 }
66 
68 {
69  listbox& stats_list = find_widget<listbox>(&window, "game_stats_list", false);
70  listbox& settings_list = find_widget<listbox>(&window, "scenario_settings_list", false);
71 
72  for(const auto& team : board_.teams()) {
73  if(team.hidden()) {
74  continue;
75  }
76 
77  team_data_.emplace_back(board_, team);
78 
79  widget_data row_data_stats;
80  widget_item column_stats;
81 
82  const bool known = viewing_team_.knows_about_team(team.side() - 1);
83  const bool enemy = viewing_team_.is_enemy(team.side());
84 
85  const team_data& data = team_data_.back();
86 
87  unit_const_ptr leader = get_leader(team.side());
88 
89  std::string leader_name;
90  std::string leader_image;
91 
93  if(leader) {
94  const bool visible = leader->is_visible_to_team(leader->get_location(), viewing_team_, see_all);
95 
96  // Add leader image. If it's fogged/[hides], show only a random leader image.
97  if(visible || known) {
98  leader_image = leader->absolute_image() + leader->image_mods();
99  leader_name = leader->name();
100  } else {
101  leader_image = formatter() << "units/unknown-unit.png" << "~RC(magenta>" << team.color() << ")";
102  leader_name = _("Unknown");
103  }
104 
106  if(resources::controller->get_classification().is_multiplayer()) {
107  leader_name = team.side_name();
108  }
109  }
110 
111  leader_name = "<span color='" + team::get_side_highlight_pango(team.side()) + "'>" + leader_name + "</span>";
112  }
113 
114  //
115  // Status list
116  //
117  column_stats["use_markup"] = "true";
118 
119  column_stats["label"] = leader_image;
120  row_data_stats.emplace("team_leader_image", column_stats);
121 
122  column_stats["label"] = leader_name + "\n" + controller_name(team);
123  column_stats["tooltip"] = team::get_side_color_name_for_UI(team.side());
124  row_data_stats.emplace("team_leader_name", column_stats);
125  column_stats.erase("tooltip");
126 
127  column_stats["label"] = team.user_team_name().empty() ? team.team_name() : team.user_team_name().str();
128  row_data_stats.emplace("team_name", column_stats);
129 
130  // Only fill in the rest of the info if the side is known...
131  if(known || see_all) {
132  std::string gold_str;
133  if(see_all || !enemy || !viewing_team_.uses_fog()) {
134  gold_str = utils::half_signed_value(team.gold());
135  }
136 
137  column_stats["label"] = team.gold() < 0 ? "<span color='#ff0000'>" + gold_str + "</span>" : gold_str;
138  row_data_stats.emplace("team_gold", column_stats);
139 
140  std::string village_count = std::to_string(team.villages().size());
142  village_count += "/" + std::to_string(board_.map().villages().size());
143  }
144 
145  column_stats["label"] = village_count;
146  row_data_stats.emplace("team_villages", column_stats);
147 
148  column_stats["label"] = std::to_string(data.units);
149  row_data_stats.emplace("team_units", column_stats);
150 
151  column_stats["label"] = std::to_string(data.upkeep);
152  row_data_stats.emplace("team_upkeep", column_stats);
153 
154  const std::string income = utils::signed_value(data.net_income);
155  column_stats["label"] = data.net_income < 0 ? "<span color='#ff0000'>" + income + "</span>" : income;
156  row_data_stats.emplace("team_income", column_stats);
157  }
158 
159  stats_list.add_row(row_data_stats);
160 
161  //
162  // Settings list
163  //
164  widget_data row_data_settings;
165  widget_item column_settings;
166 
167  column_settings["use_markup"] = "true";
168 
169  column_settings["label"] = leader_image;
170  row_data_settings.emplace("team_leader_image", column_settings);
171 
172  column_settings["label"] = leader_name + "\n" + controller_name(team);
173  row_data_settings.emplace("team_leader_name", column_settings);
174 
175  column_settings["label"] = std::to_string(team.side());
176  row_data_settings.emplace("team_side", column_settings);
177 
178  column_settings["label"] = std::to_string(team.start_gold());
179  row_data_settings.emplace("team_start_gold", column_settings);
180 
181  column_settings["label"] = std::to_string(team.base_income());
182  row_data_settings.emplace("team_base_income", column_settings);
183 
184  column_settings["label"] = std::to_string(team.village_gold());
185  row_data_settings.emplace("team_village_gold", column_settings);
186 
187  column_settings["label"] = std::to_string(team.village_support());
188  row_data_settings.emplace("team_village_support", column_settings);
189 
190  column_settings["label"] = team.uses_fog() ? _("yes") : _("no");
191  row_data_settings.emplace("team_fog", column_settings);
192 
193  column_settings["label"] = team.uses_shroud() ? _("yes") : _("no");
194  row_data_settings.emplace("team_shroud", column_settings);
195 
196  settings_list.add_row(row_data_settings);
197  }
198 
199  // Sorting options for the status list
200  stats_list.register_translatable_sorting_option(0, [this](const int i) {
201  unit_const_ptr leader = get_leader(i + 1);
202  return leader ? leader->name().str() : "";
203  });
204 
205  stats_list.register_translatable_sorting_option(1, [this](const int i) {
206  return board_.teams()[i].user_team_name().str(); });
207  stats_list.register_sorting_option(2, [this](const int i) { return board_.teams()[i].gold(); });
208  stats_list.register_sorting_option(3, [this](const int i) { return board_.teams()[i].villages(); });
209  stats_list.register_sorting_option(4, [this](const int i) { return team_data_[i].units; });
210  stats_list.register_sorting_option(5, [this](const int i) { return team_data_[i].upkeep; });
211  stats_list.register_sorting_option(6, [this](const int i) { return team_data_[i].net_income; });
212 
213  // Sorting options for the settings list
214  settings_list.register_translatable_sorting_option(0, [this](const int i) {
215  unit_const_ptr leader = get_leader(i + 1);
216  return leader ? leader->name().str() : "";
217  });
218 
219  settings_list.register_sorting_option(1, [this](const int i) { return board_.teams()[i].side(); });
220  settings_list.register_sorting_option(2, [this](const int i) { return board_.teams()[i].start_gold(); });
221  settings_list.register_sorting_option(3, [this](const int i) { return board_.teams()[i].base_income(); });
222  settings_list.register_sorting_option(4, [this](const int i) { return board_.teams()[i].village_gold(); });
223  settings_list.register_sorting_option(5, [this](const int i) { return board_.teams()[i].village_support(); });
224  settings_list.register_sorting_option(6, [this](const int i) { return board_.teams()[i].uses_fog(); });
225  settings_list.register_sorting_option(7, [this](const int i) { return board_.teams()[i].uses_shroud(); });
226 
227  //
228  // Set up tab control
229  //
230  listbox& tab_bar = find_widget<listbox>(&window, "tab_bar", false);
231 
232  window.keyboard_capture(&tab_bar);
233 
234  connect_signal_notify_modified(tab_bar, std::bind(&game_stats::on_tab_select, this));
235 
236  on_tab_select();
237 }
238 
240 {
241  const int i = find_widget<listbox>(get_window(), "tab_bar", false).get_selected_row();
242 
243  find_widget<stacked_widget>(get_window(), "pager", false).select_layer(i);
244 
245  // There are only two tabs, so this is simple
246  find_widget<label>(get_window(), "title", false).set_label(
247  i == 0 ? _("Current Status") : _("Scenario Settings")
248  );
249 }
250 
252 {
253  if(get_retval() == retval::OK) {
254  const int selected_tab = find_widget<listbox>(&window, "tab_bar", false).get_selected_row();
255 
256  const std::string list_id = selected_tab == 0 ? "game_stats_list" : "scenario_settings_list";
257  selected_side_number_ = team_data_[find_widget<listbox>(&window, list_id, false).get_selected_row()].side;
258  }
259 }
260 
261 } // namespace dialogs
double t
Definition: astarsearch.cpp:63
std::vector< std::string > names
Definition: build_info.cpp:67
Abstract class for exposing game data that doesn't depend on the GUI, however which for historical re...
virtual const gamemap & map() const =0
virtual const std::vector< team > & teams() const =0
virtual const unit_map & units() const =0
bool show_everything() const
Definition: display.hpp:104
std::ostringstream wrapper.
Definition: formatter.hpp:40
const std::vector< map_location > & villages() const
Return a list of the locations of villages on the map.
Definition: map.hpp:237
unit_const_ptr get_leader(const int side)
Definition: game_stats.cpp:50
const team & viewing_team_
Definition: game_stats.hpp:49
std::vector< team_data > team_data_
Definition: game_stats.hpp:51
virtual void pre_show(window &window) override
Actions to be taken before showing the window.
Definition: game_stats.cpp:67
virtual void post_show(window &window) override
Actions to be taken after the window has been shown.
Definition: game_stats.cpp:251
const display_context & board_
Definition: game_stats.hpp:47
Abstract base class for all modal dialogs.
int get_retval() const
Returns the cached window exit code.
window * get_window()
Returns a pointer to the dialog's window.
The listbox class.
Definition: listbox.hpp:43
grid & add_row(const widget_item &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:59
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:613
void register_sorting_option(const int col, const Func &f)
Definition: listbox.hpp:260
base class of top level items, the only item which needs to store the final canvases to draw on.
Definition: window.hpp:61
void keyboard_capture(widget *widget)
Definition: window.cpp:1221
game_display & get_display() override
Get a reference to a display member a derived class uses.
bool empty() const
Definition: tstring.hpp:186
const std::string & str() const
Definition: tstring.hpp:190
This class stores all the data for a single 'side' (in game nomenclature).
Definition: team.hpp:74
static std::string get_side_highlight_pango(int side)
Definition: team.cpp:1030
bool uses_shroud() const
Definition: team.hpp:303
const std::string & color() const
Definition: team.hpp:242
const std::string & side_name() const
Definition: team.hpp:293
int side() const
Definition: team.hpp:174
int village_support() const
Definition: team.hpp:185
const std::string & team_name() const
Definition: team.hpp:282
int village_gold() const
Definition: team.hpp:178
bool is_enemy(int n) const
Definition: team.hpp:229
const std::set< map_location > & villages() const
Definition: team.hpp:170
bool knows_about_team(std::size_t index) const
Definition: team.cpp:703
int gold() const
Definition: team.hpp:175
static const t_string get_side_color_name_for_UI(unsigned side)
Definition: team.cpp:998
int start_gold() const
Definition: team.hpp:176
int base_income() const
Definition: team.hpp:177
bool uses_fog() const
Definition: team.hpp:304
bool hidden() const
Definition: team.hpp:333
const t_string & user_team_name() const
Definition: team.hpp:283
unit_iterator end()
Definition: map.hpp:428
unit_iterator find_leader(int side)
Definition: map.cpp:320
std::size_t i
Definition: function.cpp:968
static lg::log_domain log_display("display")
static std::string _(const char *str)
Definition: gettext.hpp:93
This file contains the window object, this object is a top level container which has the event manage...
const bool & debug
Definition: game_config.cpp:91
static std::string controller_name(const team &t)
Definition: game_stats.cpp:61
REGISTER_DIALOG(editor_edit_unit)
void connect_signal_notify_modified(dispatcher &dispatcher, const signal_notification &signal)
Connects a signal handler for getting a notification upon modification.
Definition: dispatcher.cpp:203
std::map< std::string, widget_item > widget_data
Definition: widget.hpp:34
std::map< std::string, t_string > widget_item
Definition: widget.hpp:31
@ OK
Dialog was closed with the OK button.
Definition: retval.hpp:35
play_controller * controller
Definition: resources.cpp:21
std::string half_signed_value(int val)
Sign with Unicode "−" if negative.
std::string signed_value(int val)
Convert into a signed value (using the Unicode "−" and +0 convention.
@ enemy
Belongs to a non-friendly side; normally visualised by not displaying an orb.
std::string_view data
Definition: picture.cpp:194
std::shared_ptr< const unit > unit_const_ptr
Definition: ptr.hpp:27
std::array< T, size()> sized_array
Provide a alias template for an array of matching size.
Definition: enum_base.hpp:92
pointer get_shared_ptr() const
This is exactly the same as operator-> but it's slightly more readable, and can replace &*iter syntax...
Definition: map.hpp:217