The Battle for Wesnoth  1.15.11+dev
unit_attack.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2010 - 2018 by Mark de Wever <koraq@xs4all.nl>
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 
19 #include "font/text_formatting.hpp"
22 #include "gui/widgets/button.hpp"
23 #include "gui/widgets/label.hpp"
24 #include "gui/widgets/image.hpp"
25 #include "gui/widgets/listbox.hpp"
26 #include "gui/widgets/settings.hpp"
28 #include "gui/widgets/window.hpp"
29 #include "game_config.hpp"
30 #include "game_display.hpp"
31 #include "gettext.hpp"
32 #include "help/help.hpp"
33 #include "language.hpp"
34 #include "color.hpp"
35 #include "units/unit.hpp"
36 
37 #include <functional>
38 
39 namespace gui2::dialogs
40 {
41 
43 
44 unit_attack::unit_attack(const unit_map::iterator& attacker_itor,
45  const unit_map::iterator& defender_itor,
46  std::vector<battle_context>&& weapons,
47  const int best_weapon)
48  : selected_weapon_(-1)
49  , attacker_itor_(attacker_itor)
50  , defender_itor_(defender_itor)
51  , weapons_(std::move(weapons))
52  , best_weapon_(best_weapon)
53 {
54 }
55 
57 {
58  const std::size_t index = find_widget<listbox>(get_window(), "weapon_list", false).get_selected_row();
59  attack_predictions::display(weapons_[index], attacker_itor_.get_shared_ptr(), defender_itor_.get_shared_ptr());
60 }
61 
63 {
65  find_widget<button>(&window, "damage_calculation", false),
66  std::bind(&unit_attack::damage_calc_callback, this));
67 
68  find_widget<unit_preview_pane>(&window, "attacker_pane", false)
69  .set_displayed_unit(*attacker_itor_);
70 
71  find_widget<unit_preview_pane>(&window, "defender_pane", false)
72  .set_displayed_unit(*defender_itor_);
73 
74  selected_weapon_ = -1;
75 
76  listbox& weapon_list = find_widget<listbox>(&window, "weapon_list", false);
77  window.keyboard_capture(&weapon_list);
78 
79  // Possible TODO: If a "blank weapon" is generally useful, add it as a static member in attack_type.
80  static const config empty;
81  static const_attack_ptr no_weapon(new attack_type(empty));
82 
83  for(const auto & weapon : weapons_) {
84  const battle_context_unit_stats& attacker = weapon.get_attacker_stats();
85  const battle_context_unit_stats& defender = weapon.get_defender_stats();
86 
87  const attack_type& attacker_weapon =
88  *attacker.weapon;
89  const attack_type& defender_weapon = defender.weapon ?
90  *defender.weapon : *no_weapon;
91 
92  const color_t a_cth_color = game_config::red_to_green(attacker.chance_to_hit);
93  const color_t d_cth_color = game_config::red_to_green(defender.chance_to_hit);
94 
95  const std::string attw_name = !attacker_weapon.name().empty() ? attacker_weapon.name() : " ";
96  const std::string defw_name = !defender_weapon.name().empty() ? defender_weapon.name() : " ";
97 
98  std::string range = attacker_weapon.range().empty() ? defender_weapon.range() : attacker_weapon.range();
99  if (!range.empty()) {
100  range = string_table["range_" + range];
101  }
102 
103  auto a_ctx = attacker_weapon.specials_context(
106  attacker_itor_->get_location(),
107  defender_itor_->get_location(), true, defender.weapon
108  );
109 
110  auto d_ctx = defender_weapon.specials_context(
113  defender_itor_->get_location(),
114  attacker_itor_->get_location(), false, attacker.weapon
115  );
116 
117  std::string attw_specials = attacker_weapon.weapon_specials(true, attacker.backstab_pos);
118  std::string defw_specials = defender_weapon.weapon_specials(true);
119 
120  if(!attw_specials.empty()) {
121  attw_specials = " " + attw_specials;
122  }
123 
124  if(!defw_specials.empty()) {
125  defw_specials = " " + defw_specials;
126  }
127 
128  std::stringstream attacker_stats, defender_stats;
129 
130  // Use attacker/defender.num_blows instead of attacker/defender_weapon.num_attacks() because the latter does not consider the swarm weapon special
131  attacker_stats << "<b>" << attw_name << "</b>" << "\n"
132  << attacker.damage << font::weapon_numbers_sep << attacker.num_blows
133  << attw_specials << "\n"
134  << font::span_color(a_cth_color) << attacker.chance_to_hit << "%</span>";
135 
136  defender_stats << "<b>" << defw_name << "</b>" << "\n"
137  << defender.damage << font::weapon_numbers_sep << defender.num_blows
138  << defw_specials << "\n"
139  << font::span_color(d_cth_color) << defender.chance_to_hit << "%</span>";
140 
141  std::map<std::string, string_map> data;
143 
144  item["use_markup"] = "true";
145 
146  item["label"] = attacker_weapon.icon();
147  data.emplace("attacker_weapon_icon", item);
148 
149  item["label"] = attacker_stats.str();
150  data.emplace("attacker_weapon", item);
151 
152  item["label"] = "<span color='#a69275'>" + font::unicode_em_dash + " " + range + " " + font::unicode_em_dash + "</span>";
153  data.emplace("range", item);
154 
155  item["label"] = defender_stats.str();
156  data.emplace("defender_weapon", item);
157 
158  item["label"] = defender_weapon.icon();
159  data.emplace("defender_weapon_icon", item);
160 
161  weapon_list.add_row(data);
162  }
163 
164  // If these two aren't the same size, we can't use list selection incides
165  // to access to weapons list!
166  assert(weapons_.size() == weapon_list.get_item_count());
167 
168  weapon_list.select_row(best_weapon_);
169 }
170 
172 {
173  if(get_retval() == retval::OK) {
174  selected_weapon_ = find_widget<listbox>(&window, "weapon_list", false).get_selected_row();
175  }
176 }
177 
178 } // 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:52
std::string weapon_specials(bool only_active=false, bool is_backstab=false) const
Returns a comma-separated string of active names for the specials of *this.
Definition: abilities.cpp:837
int best_weapon_
The best weapon, aka the one high-lighted.
Definition: unit_attack.hpp:77
This file contains the window object, this object is a top level container which has the event manage...
STL namespace.
window * get_window() const
Returns a pointer to the dialog&#39;s window.
unsigned int chance_to_hit
Effective chance to hit as a percentage (all factors accounted for).
Definition: attack.hpp:75
bool select_row(const unsigned row, const bool select=true)
Selects a row.
Definition: listbox.cpp:251
std::vector< battle_context > weapons_
List of all battle contexts used for getting the weapons.
Definition: unit_attack.hpp:74
The listbox class.
Definition: listbox.hpp:42
bool backstab_pos
True if the attacker is in position to backstab the defender (this is used to determine whether to ap...
Definition: attack.hpp:62
std::string span_color(const color_t &color)
Returns a Pango formatting string using the provided color_t object.
int damage
Effective damage of the weapon (all factors accounted for).
Definition: attack.hpp:76
This file contains the settings handling of the widget library.
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:171
const t_string & name() const
Definition: attack_type.hpp:42
Computes the statistics of a battle between an attacker and a defender unit.
Definition: attack.hpp:172
virtual void post_show(window &window) override
Actions to be taken after the window has been shown.
const std::string & range() const
Definition: attack_type.hpp:46
unsigned get_item_count() const
Returns the number of items in the listbox.
Definition: listbox.cpp:132
void unit_attack(display *disp, game_board &board, const map_location &a, const map_location &b, int damage, const attack_type &attack, const_attack_ptr secondary_attack, int swing, const std::string &hit_text, int drain_amount, const std::string &att_text, const std::vector< std::string > *extra_hit_sounds, bool attacking)
Make the unit on tile &#39;a&#39; attack the unit on tile &#39;b&#39;.
Definition: udisplay.cpp:599
const std::string & icon() const
Definition: attack_type.hpp:45
Structure describing the statistics of a unit involved in the battle.
Definition: attack.hpp:50
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
int selected_weapon_
The index of the selected weapon.
Definition: unit_attack.hpp: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
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
int get_retval() const
Returns the cached window exit code.
bool empty() const
Definition: tstring.hpp:186
const std::string weapon_numbers_sep
Definition: constants.cpp:48
color_t red_to_green(int val, bool for_text)
Return a color corresponding to the value val red for val=0 to green for val=100, passing by yellow...
This shows the dialog for attacking units.
Definition: unit_attack.hpp:40
symbol_table string_table
Definition: language.cpp:64
const std::string unicode_em_dash
Definition: constants.cpp:43
unit_map::iterator attacker_itor_
Iterator pointing to the attacker.
Definition: unit_attack.hpp:68
Container associating units to locations.
Definition: map.hpp:97
unsigned int num_blows
Effective number of blows, takes swarm into account.
Definition: attack.hpp:80
specials_context_t specials_context(unit_const_ptr self, unit_const_ptr other, const map_location &unit_loc, const map_location &other_loc, bool attacking, const_attack_ptr other_attack) const
Dialog was closed with the OK button.
Definition: retval.hpp:34
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:59
std::shared_ptr< const attack_type > const_attack_ptr
Definition: ptr.hpp:33
virtual void pre_show(window &window) override
Actions to be taken before showing the window.
Definition: unit_attack.cpp:62
base class of top level items, the only item which needs to store the final canvases to draw on...
Definition: window.hpp:64
std::string::const_iterator iterator
Definition: tokenizer.hpp:24
std::pair< std::string, unsigned > item
Definition: help_impl.hpp:409
unit_map::iterator defender_itor_
Iterator pointing to the defender.
Definition: unit_attack.hpp:71