The Battle for Wesnoth  1.15.1+dev
drawer.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2014 - 2018 by Chris Beck <render787@gmail.com>
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 #include "units/drawer.hpp"
16 
17 #include "display.hpp"
18 #include "display_context.hpp"
19 #include "formatter.hpp"
20 #include "game_display.hpp"
21 #include "preferences/game.hpp"
22 #include "halo.hpp"
23 #include "map/map.hpp"
24 #include "map/location.hpp"
25 #include "color.hpp"
26 #include "sdl/surface.hpp"
27 #include "team.hpp"
28 #include "units/unit.hpp"
29 #include "units/animation.hpp"
31 #include "units/frame.hpp"
32 
33 // Map of different energy bar surfaces and their dimensions.
34 static std::map<surface, SDL_Rect> energy_bar_rects;
35 
37  disp(thedisp),
38  dc(disp.get_disp_context()),
39  map(dc.map()),
40  teams(dc.teams()),
41  halo_man(thedisp.get_halo_manager()),
42  viewing_team(disp.viewing_team()),
43  playing_team(disp.playing_team()),
44  viewing_team_ref(teams[viewing_team]),
45  playing_team_ref(teams[playing_team]),
46  is_blindfolded(disp.is_blindfolded()),
47  show_everything(disp.show_everything()),
48  sel_hex(disp.selected_hex()),
49  mouse_hex(disp.mouseover_hex()),
50  zoom_factor(disp.get_zoom_factor()),
51  hex_size(disp.hex_size()),
52  hex_size_by_2(disp.hex_size()/2)
53 {
54  if(const game_display* game_display = dynamic_cast<class game_display*>(&disp)) {
56  }
57 }
58 
59 void unit_drawer::redraw_unit (const unit & u) const
60 {
62  map_location loc = u.get_location();
63 
64  int side = u.side();
65 
66  bool hidden = u.get_hidden();
67  bool is_flying = u.is_flying();
68  map_location::DIRECTION facing = u.facing();
69  int hitpoints = u.hitpoints();
70  int max_hitpoints = u.max_hitpoints();
71  int movement_left = u.movement_left();
72  int total_movement = u.total_movement();
73 
74  bool can_recruit = u.can_recruit();
75  bool can_advance = u.can_advance();
76 
77  int experience = u.experience();
78  int max_experience = u.max_experience();
79 
80  bool emit_zoc = u.emits_zoc();
81 
82  color_t hp_color=u.hp_color();
83  color_t xp_color=u.xp_color();
84 
85  std::string ellipse=u.image_ellipse();
86 
87  const bool is_highlighted_enemy = units_that_can_reach_goal.count(loc) > 0;
88  const bool is_selected_hex = (loc == sel_hex || is_highlighted_enemy);
89 
91  ac.clear_haloes();
92  if(ac.anim_) {
93  ac.anim_->update_last_draw_time();
94  }
95  return;
96  }
97 
98  if (!ac.anim_) {
99  ac.set_standing();
100  if (!ac.anim_) return;
101  }
102 
103  if (ac.refreshing_) return;
104  ac.refreshing_ = true;
105 
106  ac.anim_->update_last_draw_time();
107  frame_parameters params;
109  const terrain_type& terrain_info = map.get_terrain_info(terrain);
110 
111  // do not set to 0 so we can distinguish the flying from the "not on submerge terrain"
112  // instead use -1.0 (as in "negative depth", it will be ignored by rendering)
113  params.submerge= is_flying ? -1.0 : terrain_info.unit_submerge();
114 
115  if(u.invisible(loc) && params.highlight_ratio > 0.6) {
116  params.highlight_ratio = 0.6;
117  }
118  if (is_selected_hex && params.highlight_ratio == 1.0) {
119  params.highlight_ratio = 1.5;
120  }
121 
122  int height_adjust = static_cast<int>(terrain_info.unit_height_adjust() * zoom_factor);
123  if (is_flying && height_adjust < 0) {
124  height_adjust = 0;
125  }
126  params.y -= height_adjust;
127  params.halo_y -= height_adjust;
128 
129  int red = 0,green = 0,blue = 0,tints = 0;
130  double blend_ratio = 0;
131  // Add future colored states here
132  if(u.poisoned()) {
133  green += 255;
134  blend_ratio += 0.25;
135  tints += 1;
136  }
137  if(u.slowed()) {
138  red += 191;
139  green += 191;
140  blue += 255;
141  blend_ratio += 0.25;
142  tints += 1;
143  }
144  if(tints > 0) {
145  params.blend_with = color_t((red/tints),(green/tints),(blue/tints));
146  params.blend_ratio = ((blend_ratio/tints));
147  }
148 
149  //hackish : see unit_frame::merge_parameters
150  // we use image_mod on the primary image
151  // and halo_mod on secondary images and all haloes
152  params.image_mod = u.image_mods();
153  params.halo_mod = u.TC_image_mods();
154  params.image= u.default_anim_image();
155 
156 
157  if(u.incapacitated()) params.image_mod +="~GS()";
158  params.primary_frame = true;
159 
160 
161  const frame_parameters adjusted_params = ac.anim_->get_current_params(params);
162 
163  const map_location dst = loc.get_direction(facing);
164  const int xsrc = disp.get_location_x(loc);
165  const int ysrc = disp.get_location_y(loc);
166  const int xdst = disp.get_location_x(dst);
167  const int ydst = disp.get_location_y(dst);
168 
169  const int x = static_cast<int>(adjusted_params.offset * xdst + (1.0-adjusted_params.offset) * xsrc) + hex_size_by_2;
170  const int y = static_cast<int>(adjusted_params.offset * ydst + (1.0-adjusted_params.offset) * ysrc) + hex_size_by_2;
171 
172  bool has_halo = ac.unit_halo_ && ac.unit_halo_->valid();
173  if(!has_halo && !u.image_halo().empty()) {
174  ac.unit_halo_ = halo_man.add(x, y - height_adjust, u.image_halo()+u.TC_image_mods(), map_location(-1, -1));
175  }
176  if(has_halo && u.image_halo().empty()) {
178  ac.unit_halo_.reset();
179  } else if(has_halo) {
180  halo_man.set_location(ac.unit_halo_, x, y - height_adjust);
181  }
182 
183  // We draw bars only if wanted, visible on the map view
184  bool draw_bars = ac.draw_bars_ ;
185  if (draw_bars) {
186  SDL_Rect unit_rect {xsrc, ysrc +adjusted_params.y, hex_size, hex_size};
187  draw_bars = sdl::rects_overlap(unit_rect, disp.map_outside_area());
188  }
189  surface ellipse_front(nullptr);
190  surface ellipse_back(nullptr);
191  int ellipse_floating = 0;
192  // Always show the ellipse for selected units
193  if(draw_bars && (preferences::show_side_colors() || is_selected_hex)) {
194  if(adjusted_params.submerge > 0.0) {
195  // The division by 2 seems to have no real meaning,
196  // It just works fine with the current center of ellipse
197  // and prevent a too large adjust if submerge = 1.0
198  ellipse_floating = static_cast<int>(adjusted_params.submerge * hex_size_by_2);
199  }
200 
201  if(ellipse.empty()){
202  ellipse="misc/ellipse";
203  }
204 
205  if(ellipse != "none") {
206  // check if the unit has a ZoC or can recruit
207  const std::string nozoc = !emit_zoc ? "nozoc-" : "";
208  const std::string leader = can_recruit ? "leader-" : "";
209  const std::string selected = is_selected_hex? "selected-" : "";
210  const std::string tc = team::get_side_color_id(side);
211 
212  const std::string ellipse_top = formatter() << ellipse << "-" << leader << nozoc << selected << "top.png~RC(ellipse_red>" << tc << ")";
213  const std::string ellipse_bot = formatter() << ellipse << "-" << leader << nozoc << selected << "bottom.png~RC(ellipse_red>" << tc << ")";
214 
215  // Load the ellipse parts recolored to match team color
216  ellipse_back = image::get_image(image::locator(ellipse_top), image::SCALED_TO_ZOOM);
217  ellipse_front = image::get_image(image::locator(ellipse_bot), image::SCALED_TO_ZOOM);
218  }
219  }
220  if (ellipse_back != nullptr) {
221  //disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
223  xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
224  }
225 
226  if (ellipse_front != nullptr) {
227  //disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
229  xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
230  }
231  if(draw_bars) {
232  const image::locator* orb_img = nullptr;
233 
234  const auto& type_cfg = u.type().get_cfg();
235  const auto& cfg_offset_x = type_cfg["bar_offset_x"];
236  const auto& cfg_offset_y = type_cfg["bar_offset_y"];
237  int xoff;
238  int yoff;
239  if(cfg_offset_x.empty() && cfg_offset_y.empty()) {
241  xoff = !unit_img ? 0 : (hex_size - unit_img->w)/2;
242  yoff = !unit_img ? 0 : (hex_size - unit_img->h)/2;
243  }
244  else {
245  xoff = cfg_offset_x.to_int();
246  yoff = cfg_offset_y.to_int();
247  }
248 
249  /*static*/ const image::locator partmoved_orb(game_config::images::orb + "~RC(magenta>" +
250  preferences::partial_color() + ")" );
251  /*static*/ const image::locator moved_orb(game_config::images::orb + "~RC(magenta>" +
252  preferences::moved_color() + ")" );
253  /*static*/ const image::locator ally_orb(game_config::images::orb + "~RC(magenta>" +
254  preferences::allied_color() + ")" );
255  /*static*/ const image::locator enemy_orb(game_config::images::orb + "~RC(magenta>" +
256  preferences::enemy_color() + ")" );
257  /*static*/ const image::locator unmoved_orb(game_config::images::orb + "~RC(magenta>" +
258  preferences::unmoved_color() + ")" );
259 
260  const std::string* energy_file = &game_config::images::energy;
261 
262  if(std::size_t(side) != viewing_team+1) {
263  if(disp.team_valid() &&
264  viewing_team_ref.is_enemy(side)) {
266  orb_img = &enemy_orb;
267  else
268  orb_img = nullptr;
269  } else {
271  orb_img = &ally_orb;
272  else orb_img = nullptr;
273  }
274  } else {
276  orb_img = &moved_orb;
277  else orb_img = nullptr;
278 
279  if(playing_team == viewing_team && !u.user_end_turn()) {
280  if (movement_left == total_movement) {
282  orb_img = &unmoved_orb;
283  else orb_img = nullptr;
284  } else if ( dc.unit_can_move(u) ) {
286  orb_img = &partmoved_orb;
287  else orb_img = nullptr;
288  }
289  }
290  }
291 
292  if (orb_img != nullptr) {
295  loc, xsrc + xoff, ysrc + yoff + adjusted_params.y, orb);
296  }
297 
298  double unit_energy = 0.0;
299  if(max_hitpoints > 0) {
300  unit_energy = static_cast<double>(hitpoints)/static_cast<double>(max_hitpoints);
301  }
302  const int bar_shift = static_cast<int>(-5*zoom_factor);
303  const int hp_bar_height = static_cast<int>(max_hitpoints * u.hp_bar_scaling());
304 
305  const fixed_t bar_alpha = (loc == mouse_hex || is_selected_hex) ? ftofxp(1.0): ftofxp(0.8);
306 
307  draw_bar(*energy_file, xsrc+xoff+bar_shift, ysrc+yoff+adjusted_params.y,
308  loc, hp_bar_height, unit_energy,hp_color, bar_alpha);
309 
310  if(experience > 0 && can_advance) {
311  const double filled = static_cast<double>(experience) / static_cast<double>(max_experience);
312  const int xp_bar_height = static_cast<int>(max_experience * u.xp_bar_scaling() / std::max<int>(u.level(),1));
313 
314  draw_bar(*energy_file, xsrc+xoff, ysrc+yoff+adjusted_params.y,
315  loc, xp_bar_height, filled, xp_color, bar_alpha);
316  }
317 
318  if (can_recruit) {
320  if(crown) {
321  //if(bar_alpha != ftofxp(1.0)) {
322  // crown = adjust_surface_alpha(crown, bar_alpha);
323  //}
325  loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, crown);
326  }
327  }
328 
329  for(const std::string& ov : u.overlays()) {
331  if(ov_img != nullptr) {
333  loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, ov_img);
334  }
335  }
336  }
337 
338  // Smooth unit movements from terrain of different elevation.
339  // Do this separately from above so that the health bar doesn't go up and down.
340 
341  const t_translation::terrain_code terrain_dst = map.get_terrain(dst);
342  const terrain_type& terrain_dst_info = map.get_terrain_info(terrain_dst);
343 
344  int height_adjust_unit = static_cast<int>((terrain_info.unit_height_adjust() * (1.0 - adjusted_params.offset) +
345  terrain_dst_info.unit_height_adjust() * adjusted_params.offset) *
346  zoom_factor);
347  if (is_flying && height_adjust_unit < 0) {
348  height_adjust_unit = 0;
349  }
350  params.y -= height_adjust_unit - height_adjust;
351  params.halo_y -= height_adjust_unit - height_adjust;
352 
353  ac.anim_->redraw(params, halo_man);
354  ac.refreshing_ = false;
355 }
356 
357 void unit_drawer::draw_bar(const std::string& image, int xpos, int ypos,
358  const map_location& loc, std::size_t height, double filled,
359  const color_t& col, fixed_t alpha) const
360 {
361 
362  filled = std::min<double>(std::max<double>(filled,0.0),1.0);
363  height = static_cast<std::size_t>(height*zoom_factor);
364 
366 
367  // We use UNSCALED because scaling (and bilinear interpolation)
368  // is bad for calculate_energy_bar.
369  // But we will do a geometric scaling later.
370  surface bar_surf(image::get_image(image));
371  if(surf == nullptr || bar_surf == nullptr) {
372  return;
373  }
374 
375  // calculate_energy_bar returns incorrect results if the surface colors
376  // have changed (for example, due to bilinear interpolation)
377  const SDL_Rect& unscaled_bar_loc = calculate_energy_bar(bar_surf);
378 
379  SDL_Rect bar_loc;
380  if (surf->w == bar_surf->w && surf->h == bar_surf->h)
381  bar_loc = unscaled_bar_loc;
382  else {
383  const fixed_t xratio = fxpdiv(surf->w,bar_surf->w);
384  const fixed_t yratio = fxpdiv(surf->h,bar_surf->h);
385  const SDL_Rect scaled_bar_loc {
386  fxptoi(unscaled_bar_loc. x * xratio)
387  , fxptoi(unscaled_bar_loc. y * yratio + 127)
388  , fxptoi(unscaled_bar_loc. w * xratio + 255)
389  , fxptoi(unscaled_bar_loc. h * yratio + 255)
390  };
391  bar_loc = scaled_bar_loc;
392  }
393 
394  if(height > static_cast<std::size_t>(bar_loc.h)) {
395  height = bar_loc.h;
396  }
397 
398  //if(alpha != ftofxp(1.0)) {
399  // surf.assign(adjust_surface_alpha(surf,alpha));
400  // if(surf == nullptr) {
401  // return;
402  // }
403  //}
404 
405  const std::size_t skip_rows = bar_loc.h - height;
406 
407  SDL_Rect top {0, 0, surf->w, bar_loc.y};
408  SDL_Rect bot = sdl::create_rect(0, bar_loc.y + skip_rows, surf->w, 0);
409  bot.h = surf->w - bot.y;
410 
411  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos, ypos, surf, top);
412  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos, ypos + top.h, surf, bot);
413 
414  std::size_t unfilled = static_cast<std::size_t>(height * (1.0 - filled));
415 
416  if(unfilled < height && alpha >= ftofxp(0.3)) {
417  const uint8_t r_alpha = std::min<unsigned>(unsigned(fxpmult(alpha,255)),255);
418  surface filled_surf(bar_loc.w, height - unfilled);
419  SDL_Rect filled_area = sdl::create_rect(0, 0, bar_loc.w, height-unfilled);
420  sdl::fill_surface_rect(filled_surf,&filled_area,SDL_MapRGBA(bar_surf->format,col.r,col.g,col.b, r_alpha));
421  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos + bar_loc.x, ypos + bar_loc.y + unfilled, filled_surf);
422  }
423 }
424 
426  bool operator()(uint32_t color) const { return (color&0xFF000000) > 0x10000000 &&
427  (color&0x00FF0000) < 0x00100000 &&
428  (color&0x0000FF00) < 0x00001000 &&
429  (color&0x000000FF) < 0x00000010; }
430 };
431 
432 const SDL_Rect& unit_drawer::calculate_energy_bar(surface surf) const
433 {
434  const std::map<surface,SDL_Rect>::const_iterator i = energy_bar_rects.find(surf);
435  if(i != energy_bar_rects.end()) {
436  return i->second;
437  }
438 
439  int first_row = -1, last_row = -1, first_col = -1, last_col = -1;
440 
441  const_surface_lock image_lock(surf);
442  const uint32_t* const begin = image_lock.pixels();
443 
444  for(int y = 0; y != surf->h; ++y) {
445  const uint32_t* const i1 = begin + surf->w*y;
446  const uint32_t* const i2 = i1 + surf->w;
447  const uint32_t* const itor = std::find_if(i1,i2,is_energy_color());
448  const int count = std::count_if(itor,i2,is_energy_color());
449 
450  if(itor != i2) {
451  if(first_row == -1) {
452  first_row = y;
453  }
454 
455  first_col = itor - i1;
456  last_col = first_col + count;
457  last_row = y;
458  }
459  }
460 
461  const SDL_Rect res {
462  first_col
463  , first_row
464  , last_col-first_col
465  , last_row+1-first_row
466  };
467  energy_bar_rects.emplace(surf, res);
468  return calculate_energy_bar(surf);
469 }
surface get_image(const image::locator &i_locator, TYPE type)
function to get the surface corresponding to an image.
Definition: picture.cpp:875
bool refreshing_
avoid infinite recursion. flag used for drawing / animation
pixel_t * pixels() const
Definition: surface.hpp:167
std::string unmoved_color()
Definition: general.cpp:343
Reserve layers to be selected for WML.
Definition: display.hpp:824
All parameters from a frame at a given instant.
Definition: frame.hpp:34
image::locator image
Definition: frame.hpp:40
bool is_blindfolded
Definition: drawer.hpp:58
This class represents a single unit of a specific type.
Definition: unit.hpp:99
#define fxptoi(x)
IN: fixed_t - OUT: int.
Definition: math.hpp:306
bool is_flying() const
Check if the unit is a flying unit.
Definition: unit.hpp:1367
bool rects_overlap(const SDL_Rect &rect1, const SDL_Rect &rect2)
Tests whether two rectangles overlap.
Definition: rect.cpp:33
const std::set< map_location > & units_that_can_reach_goal() const
Return the locations of units that can reach goal (.
std::unique_ptr< unit_animation > anim_
The current animation.
double unit_submerge() const
Definition: terrain.hpp:62
int hitpoints() const
The current number of hitpoints this unit has.
Definition: unit.hpp:453
Frame for unit&#39;s animation sequence.
bool show_enemy_orb()
Definition: general.cpp:263
int hex_size
Definition: drawer.hpp:65
bool show_allied_orb()
Definition: general.cpp:256
halo::manager & halo_man
Definition: drawer.hpp:53
void fill_surface_rect(surface &dst, SDL_Rect *dst_rect, const uint32_t color)
Fill a rectangle on a given surface.
Definition: rect.hpp:114
A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separa...
Definition: translation.hpp:50
const terrain_type & get_terrain_info(const t_translation::terrain_code &terrain) const
Definition: map.cpp:97
map_location::DIRECTION facing() const
The current directin this unit is facing within its hex.
Definition: unit.hpp:1274
bool draw_bars_
bool indicating whether to draw bars with the unit
const config & get_cfg() const
Definition: types.hpp:268
#define h
std::string image_ellipse() const
Get the unit&#39;s ellipse image.
Definition: unit.hpp:1466
-file sdl_utils.hpp
bool unit_can_move(const unit &u) const
Will return true iff the unit u has any possible moves it can do (including attacking etc)...
bool show_side_colors()
Definition: game.cpp:777
bool get_hidden() const
Gets whether this unit is currently hidden on the map.
Definition: unit.hpp:671
double hp_bar_scaling() const
The factor by which the HP bar should be scaled.
Definition: unit.hpp:683
t_translation::terrain_code get_terrain(const map_location &loc) const
Looks up terrain at a particular location.
Definition: map.cpp:309
map_location get_direction(DIRECTION dir, unsigned int n=1u) const
Definition: location.cpp:402
bool team_valid() const
Definition: display.cpp:706
const unit_type & type() const
This unit&#39;s type, accounting for gender and variation.
Definition: unit.hpp:315
color_t hp_color() const
Color for this unit&#39;s current hitpoints.
Definition: unit.cpp:1108
bool poisoned() const
Check if the unit has been poisoned.
Definition: unit.hpp:845
static const std::string & leader_crown()
The path to the leader crown overlay.
Definition: unit.cpp:1060
void clear_haloes()
Clear the haloes associated to the unit.
int unit_height_adjust() const
Definition: terrain.hpp:61
#define fxpmult(x, y)
IN: unsigned and fixed_t - OUT: unsigned.
Definition: math.hpp:300
std::string halo_mod
Definition: frame.hpp:49
std::ostringstream wrapper.
Definition: formatter.hpp:38
const SDL_Rect & calculate_energy_bar(surface surf) const
Finds the start and end rows on the energy bar image.
Definition: drawer.cpp:432
color_t xp_color() const
Color for this unit&#39;s XP.
Definition: unit.cpp:1118
#define fxpdiv(x, y)
IN: unsigned and int - OUT: fixed_t.
Definition: math.hpp:303
Unit bars and overlays are drawn on this layer (for testing here).
Definition: display.hpp:849
std::string selected
int hex_size_by_2
Definition: drawer.hpp:66
const gamemap & map
Definition: drawer.hpp:51
int max_experience() const
The max number of experience points this unit can have.
Definition: unit.hpp:483
uint8_t r
Red value.
Definition: color.hpp:177
bool is_enemy(int n) const
Definition: team.hpp:243
int level() const
The current level of this unit.
Definition: unit.hpp:513
map_display and display: classes which take care of displaying the map and game-data on the screen...
display & disp
Definition: drawer.hpp:49
std::string default_anim_image() const
The default image to use for animation frames with no defined image.
Definition: unit.cpp:2363
const std::vector< std::string > & overlays() const
Get the unit&#39;s overlay images.
Definition: unit.hpp:1500
static const ::config * terrain
The terrain used to create the cache.
Definition: minimap.cpp:130
void draw_bar(const std::string &image, int xpos, int ypos, const map_location &loc, std::size_t height, double filled, const color_t &col, fixed_t alpha) const
draw a health/xp bar of a unit
Definition: drawer.cpp:357
int32_t fixed_t
Definition: math.hpp:292
bool show_moved_orb()
Definition: general.cpp:270
std::set< map_location > units_that_can_reach_goal
Definition: drawer.hpp:63
static std::string get_side_color_id(unsigned side)
Definition: team.cpp:952
handle add(int x, int y, const std::string &image, const map_location &loc, halo::ORIENTATION orientation=NORMAL, bool infinite=true)
Add a haloing effect using &#39;image centered on (x,y).
Definition: halo.cpp:452
#define ftofxp(x)
IN: float or int - OUT: fixed_t.
Definition: math.hpp:297
Encapsulates the map of the game.
Definition: location.hpp:42
bool user_end_turn() const
Check whether the user ended their turn.
Definition: unit.hpp:743
bool invisible(const map_location &loc, bool see_all=true) const
Definition: unit.cpp:2386
boost::optional< color_t > blend_with
Definition: frame.hpp:54
std::string allied_color()
Definition: general.cpp:303
double highlight_ratio
Definition: frame.hpp:57
std::size_t i
Definition: function.cpp:933
unit_animation_component & anim_comp() const
Definition: unit.hpp:1445
int max_hitpoints() const
The max number of hitpoints this unit can have.
Definition: unit.hpp:459
std::string moved_color()
Definition: general.cpp:333
std::string image_mod
Definition: frame.hpp:43
Helper class for pinning SDL surfaces into memory.
Definition: surface.hpp:147
bool can_recruit() const
Whether this unit can recruit other units - ie, are they a leader unit.
Definition: unit.hpp:570
int get_location_y(const map_location &loc) const
Definition: display.cpp:726
const SDL_Rect & map_outside_area() const
Returns the available area for a map, this may differ from the above.
Definition: display.hpp:237
const team & viewing_team_ref
Definition: drawer.hpp:56
DIRECTION
Valid directions which can be moved in our hexagonal world.
Definition: location.hpp:44
const display_context & dc
Definition: drawer.hpp:50
int w
std::size_t viewing_team
Definition: drawer.hpp:54
void set_location(const handle &h, int x, int y)
Set the position of an existing haloing effect, according to its handle.
Definition: halo.cpp:460
bool is_visible_to_team(const team &team, bool const see_all=true) const
Definition: unit.cpp:2429
double blend_ratio
Definition: frame.hpp:56
double xp_bar_scaling() const
The factor by which the XP bar should be scaled.
Definition: unit.hpp:692
double submerge
Definition: frame.hpp:59
SDL_Rect create_rect(const int x, const int y, const int w, const int h)
Creates an SDL_Rect with the given dimensions.
Definition: rect.hpp:39
std::string image_halo() const
Get the unit&#39;s halo image.
Definition: unit.hpp:1457
std::string partial_color()
Definition: general.cpp:353
void drawing_buffer_add(const drawing_layer layer, const map_location &loc, int x, int y, const surface &surf, const SDL_Rect &clip=SDL_Rect())
Add an item to the drawing buffer.
Definition: display.cpp:1177
int get_location_x(const map_location &loc) const
Functions to get the on-screen positions of hexes.
Definition: display.cpp:721
void redraw_unit(const unit &u) const
draw a unit.
Definition: drawer.cpp:59
unit_drawer(display &thedisp)
Definition: drawer.cpp:36
int experience() const
The current number of experience points this unit has.
Definition: unit.hpp:477
const map_location & get_location() const
The current map location this unit is at.
Definition: unit.hpp:1258
this module manages the cache of images.
bool can_advance() const
Checks whether this unit has any options to advance to.
Definition: unit.hpp:231
bool incapacitated() const
Check if the unit has been petrified.
Definition: unit.hpp:854
halo::handle unit_halo_
handle to the halo of this unit
int total_movement() const
The maximum moves this unit has.
Definition: unit.hpp:1167
bool operator()(uint32_t color) const
Definition: drawer.cpp:426
bool emits_zoc() const
Tests whether the unit has a zone-of-control, considering incapacitated.
Definition: unit.hpp:1239
int side() const
The side this unit belongs to.
Definition: unit.hpp:303
void set_standing(bool with_bars=true)
Sets the animation state to standing.
bool show_unmoved_orb()
Definition: general.cpp:277
std::size_t playing_team
Definition: drawer.hpp:55
uint8_t g
Green value.
Definition: color.hpp:180
uint8_t b
Blue value.
Definition: color.hpp:183
bool show_partial_orb()
Definition: general.cpp:284
bool slowed() const
Check if the unit has been slowed.
Definition: unit.hpp:863
double zoom_factor
Definition: drawer.hpp:62
bool show_everything
Definition: drawer.hpp:59
std::string TC_image_mods() const
Constructs a recolor (RC) IPF string for this unit&#39;s team color.
Definition: unit.cpp:2537
boost::tribool primary_frame
Definition: frame.hpp:68
int movement_left() const
Gets how far a unit can move, considering the incapacitated flag.
Definition: unit.hpp:1183
std::string image_mods() const
Gets an IPF string containing all IPF image mods.
Definition: unit.cpp:2542
std::string enemy_color()
Definition: general.cpp:323
static std::map< surface, SDL_Rect > energy_bar_rects
Definition: drawer.cpp:34
map_location mouse_hex
Definition: drawer.hpp:61
void remove(const handle &h)
Remove the halo with the given handle.
Definition: halo.cpp:466
map_location sel_hex
Definition: drawer.hpp:60