The Battle for Wesnoth  1.17.12+dev
attack_predictions.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2010 - 2022
3  by Mark de Wever <koraq@xs4all.nl>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 #define GETTEXT_DOMAIN "wesnoth-lib"
17 
19 
20 #include "attack_prediction.hpp"
21 #include "color.hpp"
22 #include "config.hpp"
23 #include "font/text_formatting.hpp"
24 #include "formatter.hpp"
25 #include "formula/variant.hpp"
26 #include "game_board.hpp"
27 #include "game_config.hpp"
29 #include "gui/widgets/drawing.hpp"
30 #include "gui/widgets/label.hpp"
31 #include "gui/widgets/settings.hpp"
32 #include "gui/widgets/window.hpp"
33 #include "gettext.hpp"
34 #include "language.hpp"
35 #include "resources.hpp"
36 #include "units/abilities.hpp"
37 #include "units/unit.hpp"
38 
39 #include <iomanip>
40 
41 namespace gui2::dialogs
42 {
43 
44 REGISTER_DIALOG(attack_predictions)
45 
46 const unsigned int attack_predictions::graph_width = 270;
47 const unsigned int attack_predictions::graph_height = 170;
48 const unsigned int attack_predictions::graph_max_rows = 10;
49 
51  : modal_dialog(window_id())
52  , attacker_data_(attacker, bc.get_attacker_combatant(), bc.get_attacker_stats())
53  , defender_data_(defender, bc.get_defender_combatant(), bc.get_defender_stats())
54 {
55 }
56 
58 {
61 }
62 
63 static std::string get_probability_string(const double prob)
64 {
65  std::ostringstream ss;
66 
67  if(prob > 0.9995) {
68  ss << "100%";
69  } else {
70  ss << std::fixed << std::setprecision(1) << 100.0 * prob << '%';
71  }
72 
73  return ss.str();
74 }
75 
76 void attack_predictions::set_data(window& window, const combatant_data& attacker, const combatant_data& defender) const
77 {
78  // Each data widget in this dialog has its id prefixed by either of these identifiers.
79  const std::string widget_id_prefix = attacker.stats_.is_attacker ? "attacker" : "defender";
80 
81  const auto get_prefixed_widget_id = [&widget_id_prefix](const std::string& id) {
82  return (formatter() << widget_id_prefix << "_" << id).str();
83  };
84 
85  // Helpers for setting or hiding labels
86  const auto set_label_helper = [&](const std::string& id, const std::string& value) {
87  find_widget<label>(&window, get_prefixed_widget_id(id), false).set_label(value);
88  };
89 
90  const auto hide_label_helper = [&](const std::string& id) {
91  find_widget<label>(&window, get_prefixed_widget_id(id), false).set_visible(widget::visibility::invisible);
92  find_widget<label>(&window, get_prefixed_widget_id(id) + "_label" , false).set_visible(widget::visibility::invisible);
93  };
94 
95  std::stringstream ss;
96 
97  //
98  // Always visible fields
99  //
100 
101  // Unscathed probability
102  const color_t ndc_color = game_config::red_to_green(attacker.combatant_.untouched * 100);
103 
104  ss << font::span_color(ndc_color) << get_probability_string(attacker.combatant_.untouched) << "</span>";
105  set_label_helper("chance_unscathed", ss.str());
106 
107  // HP probability graph
108  drawing& graph_widget = find_widget<drawing>(&window, get_prefixed_widget_id("hp_graph"), false);
109  draw_hp_graph(graph_widget, attacker, defender);
110 
111  //
112  // Weapon detail fields (only shown if a weapon is present)
113  //
114 
115  if(!attacker.stats_.weapon) {
116  set_label_helper("base_damage", _("No usable weapon"));
117 
118  // FIXME: would rather have a list somewhere that I can loop over instead of hardcoding...
119  hide_label_helper("tod_modifier");
120  hide_label_helper("leadership_modifier");
121  hide_label_helper("slowed_modifier");
122 
123  return;
124  }
125 
126  ss.str("");
127 
128  // Set specials context (for safety, it should not have changed normally).
129  const_attack_ptr weapon = attacker.stats_.weapon, opp_weapon = defender.stats_.weapon;
130  auto ctx = weapon->specials_context(attacker.unit_, defender.unit_, attacker.unit_->get_location(), defender.unit_->get_location(), attacker.stats_.is_attacker, opp_weapon);
131  std::optional<decltype(ctx)> opp_ctx;
132 
133  if(opp_weapon) {
134  opp_ctx.emplace(opp_weapon->specials_context(defender.unit_, attacker.unit_, defender.unit_->get_location(), attacker.unit_->get_location(), defender.stats_.is_attacker, weapon));
135  }
136 
137  // Get damage modifiers.
138  unit_ability_list dmg_specials = weapon->get_specials_and_abilities("damage");
139  unit_abilities::effect dmg_effect(dmg_specials, weapon->damage());
140 
141  // Get the SET damage modifier, if any.
142  auto set_dmg_effect = std::find_if(dmg_effect.begin(), dmg_effect.end(),
143  [](const unit_abilities::individual_effect& e) { return e.type == unit_abilities::SET; }
144  );
145 
146  // Either user the SET modifier or the base weapon damage.
147  if(set_dmg_effect == dmg_effect.end()) {
148  ss << weapon->damage() << " (<i>" << weapon->name() << "</i>)";
149  } else {
150  assert(set_dmg_effect->ability);
151  ss << set_dmg_effect->value << " (<i>" << (*set_dmg_effect->ability)["name"] << "</i>)";
152  }
153 
154  // Process the ADD damage modifiers.
155  for(const auto& e : dmg_effect) {
156  if(e.type == unit_abilities::ADD) {
157  ss << "\n";
158 
159  if(e.value >= 0) {
160  ss << '+';
161  }
162 
163  ss << e.value;
164  ss << " (<i>" << (*e.ability)["name"] << "</i>)";
165  }
166  }
167 
168  // Process the MUL damage modifiers.
169  for(const auto& e : dmg_effect) {
170  if(e.type == unit_abilities::MUL) {
171  ss << "\n";
172  ss << font::unicode_multiplication_sign << (e.value / 100);
173 
174  if(e.value % 100) {
175  ss << "." << ((e.value % 100) / 10);
176  if(e.value % 10) {
177  ss << (e.value % 10);
178  }
179  }
180 
181  ss << " (<i>" << (*e.ability)["name"] << "</i>)";
182  }
183  }
184 
185  set_label_helper("base_damage", ss.str());
186 
187  ss.str("");
188 
189  // Resistance modifier.
190  const int resistance_modifier = defender.unit_->damage_from(*weapon, !attacker.stats_.is_attacker, defender.unit_->get_location(), opp_weapon);
191  if(resistance_modifier != 100) {
192  if(attacker.stats_.is_attacker) {
193  if(resistance_modifier < 100) {
194  ss << _("Defender resistance vs") << " ";
195  } else {
196  ss << _("Defender vulnerability vs") << " ";
197  }
198  } else {
199  if(resistance_modifier < 100) {
200  ss << _("Attacker resistance vs") << " ";
201  } else {
202  ss << _("Attacker vulnerability vs") << " ";
203  }
204  }
205 
206  ss << string_table["type_" + weapon->type()];
207 
208  set_label_helper("resis_label", ss.str());
209 
210  ss.str("");
211  ss << font::unicode_multiplication_sign << (resistance_modifier / 100) << "." << ((resistance_modifier % 100) / 10);
212 
213  set_label_helper("resis", ss.str());
214  }
215 
216  ss.str("");
217 
218  // TODO: color format the modifiers
219 
220  // Time of day modifier.
221  const unit& u = *attacker.unit_;
222 
223  const int tod_modifier = combat_modifier(resources::gameboard->units(), resources::gameboard->map(),
224  u.get_location(), u.alignment(), u.is_fearless());
225 
226  if(tod_modifier != 0) {
227  set_label_helper("tod_modifier", utils::signed_percent(tod_modifier));
228  } else {
229  hide_label_helper("tod_modifier");
230  }
231 
232  // Leadership bonus.
233  const int leadership_bonus = under_leadership(*attacker.unit_, attacker.unit_->get_location(), weapon, opp_weapon);
234 
235  if(leadership_bonus != 0) {
236  set_label_helper("leadership_modifier", utils::signed_percent(leadership_bonus));
237  } else {
238  hide_label_helper("leadership_modifier");
239  }
240 
241  // Slowed penalty.
242  if(attacker.stats_.is_slowed) {
243  set_label_helper("slowed_modifier", "/ 2");
244  } else {
245  hide_label_helper("slowed_modifier");
246  }
247 
248  // Total damage.
249  const int base_damage = weapon->damage();
250 
251  color_t dmg_color = font::weapon_color;
252  if(attacker.stats_.damage > base_damage) {
253  dmg_color = font::good_dmg_color;
254  } else if(attacker.stats_.damage < base_damage) {
255  dmg_color = font::bad_dmg_color;
256  }
257 
258  ss << font::span_color(dmg_color) << attacker.stats_.damage << "</span>"
260 
261  set_label_helper("total_damage", ss.str());
262 
263  // Chance to hit
264  const color_t cth_color = game_config::red_to_green(attacker.stats_.chance_to_hit);
265 
266  ss.str("");
267  ss << font::span_color(cth_color) << attacker.stats_.chance_to_hit << "%</span>";
268 
269  set_label_helper("chance_to_hit", ss.str());
270 }
271 
272 void attack_predictions::draw_hp_graph(drawing& hp_graph, const combatant_data& attacker, const combatant_data& defender) const
273 {
274  // Font size. If you change this, you must update the separator space.
275  // TODO: probably should remove this.
276  const int fs = font::SIZE_SMALL;
277 
278  // Space before HP separator.
279  const int hp_sep = 30;
280 
281  // Space after percentage separator.
282  const int percent_sep = 50;
283 
284  // Bar space between both separators.
285  const int bar_space = graph_width - hp_sep - percent_sep - 4;
286 
287  // Set some variables for the WML portion of the graph to use.
288  canvas& hp_graph_canvas = hp_graph.get_drawing_canvas();
289 
290  hp_graph_canvas.set_variable("hp_column_width", wfl::variant(hp_sep));
291  hp_graph_canvas.set_variable("chance_column_width", wfl::variant(percent_sep));
292 
293  config cfg, shape;
294 
295  int i = 0;
296 
297  // Draw the rows (lower HP values are at the bottom).
298  for(const auto& probability : get_hitpoint_probabilities(attacker.combatant_.hp_dist)) {
299 
300  // Get the HP and probability.
301  auto [hp, prob] = probability;
302 
303  color_t row_color;
304 
305  // Death line is red.
306  if(hp == 0) {
307  row_color = {229, 0, 0};
308  }
309 
310  // Below current hitpoints value is orange.
311  else if(hp < static_cast<int>(attacker.stats_.hp)) {
312  // Stone is grey.
313  if(defender.stats_.petrifies) {
314  row_color = {154, 154, 154};
315  } else {
316  row_color = {244, 201, 0};
317  }
318  }
319 
320  // Current hitpoints value and above is green.
321  else {
322  row_color = {8, 202, 0};
323  }
324 
325  shape["text"] = hp;
326  shape["x"] = 4;
327  shape["y"] = 2 + (fs + 2) * i;
328  shape["w"] = "(text_width)";
329  shape["h"] = "(text_height)";
330  shape["font_size"] = 12;
331  shape["color"] = "255, 255, 255, 255";
332  shape["text_alignment"] = "(text_alignment)";
333 
334  cfg.add_child("text", shape);
335 
336  shape.clear();
337  shape["text"] = get_probability_string(prob);
338  shape["x"] = graph_width - percent_sep + 2;
339  shape["y"] = 2 + (fs + 2) * i;
340  shape["w"] = "(text_width)";
341  shape["h"] = "(text_height)";
342  shape["font_size"] = 12;
343  shape["color"] = "255, 255, 255, 255";
344  shape["text_alignment"] = "(text_alignment)";
345 
346  cfg.add_child("text", shape);
347 
348  const int bar_len = std::max(static_cast<int>((prob * (bar_space - 4)) + 0.5), 2);
349 
350  const SDL_Rect bar_rect_1 {
351  hp_sep + 4,
352  6 + (fs + 2) * i,
353  bar_len,
354  8
355  };
356 
357  shape.clear();
358  shape["x"] = bar_rect_1.x;
359  shape["y"] = bar_rect_1.y;
360  shape["w"] = bar_rect_1.w;
361  shape["h"] = bar_rect_1.h;
362  shape["fill_color"] = row_color.to_rgba_string();
363 
364  cfg.add_child("rectangle", shape);
365 
366  ++i;
367  }
368 
369  hp_graph.append_drawing_data(cfg);
370 }
371 
373 {
374  hp_probability_vector res, temp_vec;
375 
376  // First, extract any relevant probability values
377  for(int i = 0; i < static_cast<int>(hp_dist.size()); ++i) {
378  const double prob = hp_dist[i];
379 
380  // We keep only values above 0.1%.
381  if(prob > 0.001) {
382  temp_vec.emplace_back(i, prob);
383  }
384  }
385 
386  // Then sort by descending probability.
387  std::sort(temp_vec.begin(), temp_vec.end(), [](const auto& pair1, const auto& pair2) {
388  return pair1.second > pair2.second;
389  });
390 
391  // Take only the highest probability values.;
392  std::copy_n(temp_vec.begin(), std::min<int>(graph_max_rows, temp_vec.size()), std::back_inserter(res));
393 
394  // Then, we sort the hitpoint values in descending order.
395  std::sort(res.begin(), res.end(), [](const auto& pair1, const auto& pair2) {
396  return pair1.first > pair2.first;
397  });
398 
399  return res;
400 }
401 
402 } // namespace dialogs
const_attack_ptr weapon
The weapon used by the unit to attack the opponent, or nullptr if there is none.
Definition: attack.hpp:53
window(const builder_window::window_resolution &definition)
< Needs to be initialized in show.
Definition: window.cpp:263
std::string to_rgba_string() const
Returns the stored color as an "R,G,B,A" string.
Definition: color.cpp:95
double untouched
Resulting chance we were not hit by this opponent (important if it poisons)
std::vector< double > hp_dist
Resulting probability distribution (might be not as large as max_hp)
hp_probability_vector get_hitpoint_probabilities(const std::vector< double > &hp_dist) const
This class represents a single unit of a specific type.
Definition: unit.hpp:133
static std::string get_probability_string(const double prob)
std::vector< std::pair< int, double > > hp_probability_vector
unsigned int hp
Hitpoints of the unit at the beginning of the battle.
Definition: attack.hpp:70
void set_variable(const std::string &key, wfl::variant &&value)
Definition: canvas.hpp:137
const std::string & id() const
Definition: widget.cpp:111
This file contains the window object, this object is a top level container which has the event manage...
int under_leadership(const unit &u, const map_location &loc, const_attack_ptr weapon, const_attack_ptr opp_weapon)
Tests if the unit at loc is currently affected by leadership.
Definition: attack.cpp:1579
const color_t good_dmg_color
A drawing is widget with a fixed size and gives access to the canvas of the widget in the window inst...
Definition: drawing.hpp:52
void set_data(window &window, const combatant_data &attacker, const combatant_data &defender) const
static const unsigned int graph_max_rows
bool is_slowed
True if the unit is slowed at the beginning of the battle.
Definition: attack.hpp:57
void draw_hp_graph(drawing &hp_graph, const combatant_data &attacker, const combatant_data &defender) const
void clear()
Definition: config.cpp:920
static std::string _(const char *str)
Definition: gettext.hpp:93
Definitions for the interface to Wesnoth Markup Language (WML).
unsigned int chance_to_hit
Effective chance to hit as a percentage (all factors accounted for).
Definition: attack.hpp:72
const color_t weapon_color
void append_drawing_data(const ::config &cfg)
Definition: drawing.hpp:67
std::shared_ptr< const unit > unit_const_ptr
Definition: ptr.hpp:27
virtual void set_label(const t_string &label)
std::string span_color(const color_t &color)
Returns a Pango formatting string using the provided color_t object.
const color_t bad_dmg_color
int damage
Effective damage of the weapon (all factors accounted for).
Definition: attack.hpp:73
This file contains the settings handling of the widget library.
std::ostringstream wrapper.
Definition: formatter.hpp:39
void set_visible(const visibility visible)
Definition: widget.cpp:456
canvas & get_drawing_canvas()
Definition: drawing.hpp:57
game_board * gameboard
Definition: resources.cpp:21
const std::string unicode_multiplication_sign
Definition: constants.cpp:46
The basic class for representing 8-bit RGB or RGBA colour values.
Definition: color.hpp:58
Computes the statistics of a battle between an attacker and a defender unit.
Definition: attack.hpp:167
unit_alignments::type alignment() const
The alignment of this unit.
Definition: unit.hpp:478
A simple canvas which can be drawn upon.
Definition: canvas.hpp:43
virtual void pre_show(window &window) override
Actions to be taken before showing the window.
std::size_t i
Definition: function.cpp:968
The user set the widget invisible, that means:
std::string signed_percent(int val)
Convert into a percentage (using the Unicode "−" and +0% convention.
config & add_child(config_key_type key)
Definition: config.cpp:514
attack_predictions(battle_context &bc, unit_const_ptr attacker, unit_const_ptr defender)
bool is_fearless() const
Gets whether this unit is fearless - ie, unaffected by time of day.
Definition: unit.hpp:1248
const std::string weapon_numbers_sep
Definition: constants.cpp:49
int combat_modifier(const unit_map &units, const gamemap &map, const map_location &loc, unit_alignments::type alignment, bool is_fearless)
Returns the amount that a unit&#39;s damage should be multiplied by due to the current time of day...
Definition: attack.cpp:1586
const map_location & get_location() const
The current map location this unit is at.
Definition: unit.hpp:1358
symbol_table string_table
Definition: language.cpp:65
Abstract base class for all modal dialogs.
static const unsigned int graph_width
color_t red_to_green(double val, bool for_text)
Return a color corresponding to the value val red for val=0.0 to green for val=100.0, passing by yellow.
unsigned int num_blows
Effective number of blows, takes swarm into account.
Definition: attack.hpp:77
bool is_attacker
True if the unit is the attacker.
Definition: attack.hpp:55
#define e
static const unsigned int graph_height
bool petrifies
Attack petrifies opponent when it hits.
Definition: attack.hpp:60
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:60
std::shared_ptr< const attack_type > const_attack_ptr
Definition: ptr.hpp:34
base class of top level items, the only item which needs to store the final canvases to draw on...
Definition: window.hpp:66
const int SIZE_SMALL
Definition: constants.cpp:24