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