The Battle for Wesnoth  1.15.0-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 "preferences/game.hpp"
21 #include "halo.hpp"
22 #include "map/map.hpp"
23 #include "map/location.hpp"
24 #include "color.hpp"
25 #include "sdl/surface.hpp"
26 #include "team.hpp"
27 #include "units/unit.hpp"
28 #include "units/animation.hpp"
30 #include "units/frame.hpp"
31 
32 // Map of different energy bar surfaces and their dimensions.
33 static std::map<surface, SDL_Rect> energy_bar_rects;
34 
36  disp(thedisp),
37  dc(disp.get_disp_context()),
38  map(dc.map()),
39  teams(dc.teams()),
40  halo_man(thedisp.get_halo_manager()),
41  viewing_team(disp.viewing_team()),
42  playing_team(disp.playing_team()),
43  viewing_team_ref(teams[viewing_team]),
44  playing_team_ref(teams[playing_team]),
45  is_blindfolded(disp.is_blindfolded()),
46  show_everything(disp.show_everything()),
47  sel_hex(disp.selected_hex()),
48  mouse_hex(disp.mouseover_hex()),
49  zoom_factor(disp.get_zoom_factor()),
50  hex_size(disp.hex_size()),
51  hex_size_by_2(disp.hex_size()/2)
52 {}
53 
54 void unit_drawer::redraw_unit (const unit & u) const
55 {
57  map_location loc = u.get_location();
58 
59  int side = u.side();
60 
61  bool hidden = u.get_hidden();
62  bool is_flying = u.is_flying();
63  map_location::DIRECTION facing = u.facing();
64  int hitpoints = u.hitpoints();
65  int max_hitpoints = u.max_hitpoints();
66  int movement_left = u.movement_left();
67  int total_movement = u.total_movement();
68 
69  bool can_recruit = u.can_recruit();
70  bool can_advance = u.can_advance();
71 
72  int experience = u.experience();
73  int max_experience = u.max_experience();
74 
75  bool emit_zoc = u.emits_zoc();
76 
77  color_t hp_color=u.hp_color();
78  color_t xp_color=u.xp_color();
79 
80  std::string ellipse=u.image_ellipse();
81 
83  ac.clear_haloes();
84  if(ac.anim_) {
85  ac.anim_->update_last_draw_time();
86  }
87  return;
88  }
89 
90  if (!ac.anim_) {
91  ac.set_standing();
92  if (!ac.anim_) return;
93  }
94 
95  if (ac.refreshing_) return;
96  ac.refreshing_ = true;
97 
98  ac.anim_->update_last_draw_time();
99  frame_parameters params;
101  const terrain_type& terrain_info = map.get_terrain_info(terrain);
102 
103  // do not set to 0 so we can distinguish the flying from the "not on submerge terrain"
104  // instead use -1.0 (as in "negative depth", it will be ignored by rendering)
105  params.submerge= is_flying ? -1.0 : terrain_info.unit_submerge();
106 
107  if(u.invisible(loc) && params.highlight_ratio > 0.6) {
108  params.highlight_ratio = 0.6;
109  }
110  if (loc == sel_hex && params.highlight_ratio == 1.0) {
111  params.highlight_ratio = 1.5;
112  }
113 
114  int height_adjust = static_cast<int>(terrain_info.unit_height_adjust() * zoom_factor);
115  if (is_flying && height_adjust < 0) {
116  height_adjust = 0;
117  }
118  params.y -= height_adjust;
119  params.halo_y -= height_adjust;
120 
121  int red = 0,green = 0,blue = 0,tints = 0;
122  double blend_ratio = 0;
123  // Add future colored states here
124  if(u.poisoned()) {
125  green += 255;
126  blend_ratio += 0.25;
127  tints += 1;
128  }
129  if(u.slowed()) {
130  red += 191;
131  green += 191;
132  blue += 255;
133  blend_ratio += 0.25;
134  tints += 1;
135  }
136  if(tints > 0) {
137  params.blend_with = color_t((red/tints),(green/tints),(blue/tints));
138  params.blend_ratio = ((blend_ratio/tints));
139  }
140 
141  //hackish : see unit_frame::merge_parameters
142  // we use image_mod on the primary image
143  // and halo_mod on secondary images and all haloes
144  params.image_mod = u.image_mods();
145  params.halo_mod = u.TC_image_mods();
146  params.image= u.default_anim_image();
147 
148 
149  if(u.incapacitated()) params.image_mod +="~GS()";
150  params.primary_frame = true;
151 
152 
153  const frame_parameters adjusted_params = ac.anim_->get_current_params(params);
154 
155  const map_location dst = loc.get_direction(facing);
156  const int xsrc = disp.get_location_x(loc);
157  const int ysrc = disp.get_location_y(loc);
158  const int xdst = disp.get_location_x(dst);
159  const int ydst = disp.get_location_y(dst);
160 
161  const int x = static_cast<int>(adjusted_params.offset * xdst + (1.0-adjusted_params.offset) * xsrc) + hex_size_by_2;
162  const int y = static_cast<int>(adjusted_params.offset * ydst + (1.0-adjusted_params.offset) * ysrc) + hex_size_by_2;
163 
164  bool has_halo = ac.unit_halo_ && ac.unit_halo_->valid();
165  if(!has_halo && !u.image_halo().empty()) {
166  ac.unit_halo_ = halo_man.add(x, y - height_adjust, u.image_halo()+u.TC_image_mods(), map_location(-1, -1));
167  }
168  if(has_halo && u.image_halo().empty()) {
170  ac.unit_halo_.reset();
171  } else if(has_halo) {
172  halo_man.set_location(ac.unit_halo_, x, y - height_adjust);
173  }
174 
175  // We draw bars only if wanted, visible on the map view
176  bool draw_bars = ac.draw_bars_ ;
177  if (draw_bars) {
178  SDL_Rect unit_rect {xsrc, ysrc +adjusted_params.y, hex_size, hex_size};
179  draw_bars = sdl::rects_overlap(unit_rect, disp.map_outside_area());
180  }
181  surface ellipse_front(nullptr);
182  surface ellipse_back(nullptr);
183  int ellipse_floating = 0;
184  // Always show the ellipse for selected units
185  if(draw_bars && (preferences::show_side_colors() || sel_hex == loc)) {
186  if(adjusted_params.submerge > 0.0) {
187  // The division by 2 seems to have no real meaning,
188  // It just works fine with the current center of ellipse
189  // and prevent a too large adjust if submerge = 1.0
190  ellipse_floating = static_cast<int>(adjusted_params.submerge * hex_size_by_2);
191  }
192 
193  if(ellipse.empty()){
194  ellipse="misc/ellipse";
195  }
196 
197  if(ellipse != "none") {
198  // check if the unit has a ZoC or can recruit
199  const std::string nozoc = !emit_zoc ? "nozoc-" : "";
200  const std::string leader = can_recruit ? "leader-" : "";
201  const std::string selected = sel_hex == loc ? "selected-" : "";
202  const std::string tc = team::get_side_color_id(side);
203 
204  const std::string ellipse_top = formatter() << ellipse << "-" << leader << nozoc << selected << "top.png~RC(ellipse_red>" << tc << ")";
205  const std::string ellipse_bot = formatter() << ellipse << "-" << leader << nozoc << selected << "bottom.png~RC(ellipse_red>" << tc << ")";
206 
207  // Load the ellipse parts recolored to match team color
208  ellipse_back.assign(image::get_image(image::locator(ellipse_top), image::SCALED_TO_ZOOM));
209  ellipse_front.assign(image::get_image(image::locator(ellipse_bot), image::SCALED_TO_ZOOM));
210  }
211  }
212  if (ellipse_back != nullptr) {
213  //disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
215  xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
216  }
217 
218  if (ellipse_front != nullptr) {
219  //disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
221  xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
222  }
223  if(draw_bars) {
224  const image::locator* orb_img = nullptr;
225 
226  const auto& type_cfg = u.type().get_cfg();
227  const auto& cfg_offset_x = type_cfg["bar_offset_x"];
228  const auto& cfg_offset_y = type_cfg["bar_offset_y"];
229  int xoff;
230  int yoff;
231  if(cfg_offset_x.empty() && cfg_offset_y.empty()) {
233  xoff = unit_img.null() ? 0 : (hex_size - unit_img->w)/2;
234  yoff = unit_img.null() ? 0 : (hex_size - unit_img->h)/2;
235  }
236  else {
237  xoff = cfg_offset_x.to_int();
238  yoff = cfg_offset_y.to_int();
239  }
240 
241  /*static*/ const image::locator partmoved_orb(game_config::images::orb + "~RC(magenta>" +
242  preferences::partial_color() + ")" );
243  /*static*/ const image::locator moved_orb(game_config::images::orb + "~RC(magenta>" +
244  preferences::moved_color() + ")" );
245  /*static*/ const image::locator ally_orb(game_config::images::orb + "~RC(magenta>" +
246  preferences::allied_color() + ")" );
247  /*static*/ const image::locator enemy_orb(game_config::images::orb + "~RC(magenta>" +
248  preferences::enemy_color() + ")" );
249  /*static*/ const image::locator unmoved_orb(game_config::images::orb + "~RC(magenta>" +
250  preferences::unmoved_color() + ")" );
251 
252  const std::string* energy_file = &game_config::images::energy;
253 
254  if(std::size_t(side) != viewing_team+1) {
255  if(disp.team_valid() &&
256  viewing_team_ref.is_enemy(side)) {
258  orb_img = &enemy_orb;
259  else
260  orb_img = nullptr;
261  } else {
263  orb_img = &ally_orb;
264  else orb_img = nullptr;
265  }
266  } else {
268  orb_img = &moved_orb;
269  else orb_img = nullptr;
270 
271  if(playing_team == viewing_team && !u.user_end_turn()) {
272  if (movement_left == total_movement) {
274  orb_img = &unmoved_orb;
275  else orb_img = nullptr;
276  } else if ( dc.unit_can_move(u) ) {
278  orb_img = &partmoved_orb;
279  else orb_img = nullptr;
280  }
281  }
282  }
283 
284  if (orb_img != nullptr) {
287  loc, xsrc + xoff, ysrc + yoff + adjusted_params.y, orb);
288  }
289 
290  double unit_energy = 0.0;
291  if(max_hitpoints > 0) {
292  unit_energy = static_cast<double>(hitpoints)/static_cast<double>(max_hitpoints);
293  }
294  const int bar_shift = static_cast<int>(-5*zoom_factor);
295  const int hp_bar_height = static_cast<int>(max_hitpoints * u.hp_bar_scaling());
296 
297  const fixed_t bar_alpha = (loc == mouse_hex || loc == sel_hex) ? ftofxp(1.0): ftofxp(0.8);
298 
299  draw_bar(*energy_file, xsrc+xoff+bar_shift, ysrc+yoff+adjusted_params.y,
300  loc, hp_bar_height, unit_energy,hp_color, bar_alpha);
301 
302  if(experience > 0 && can_advance) {
303  const double filled = static_cast<double>(experience) / static_cast<double>(max_experience);
304  const int xp_bar_height = static_cast<int>(max_experience * u.xp_bar_scaling() / std::max<int>(u.level(),1));
305 
306  draw_bar(*energy_file, xsrc+xoff, ysrc+yoff+adjusted_params.y,
307  loc, xp_bar_height, filled, xp_color, bar_alpha);
308  }
309 
310  if (can_recruit) {
312  if(!crown.null()) {
313  //if(bar_alpha != ftofxp(1.0)) {
314  // crown = adjust_surface_alpha(crown, bar_alpha);
315  //}
317  loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, crown);
318  }
319  }
320 
321  for(const std::string& ov : u.overlays()) {
323  if(ov_img != nullptr) {
325  loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, ov_img);
326  }
327  }
328  }
329 
330  // Smooth unit movements from terrain of different elevation.
331  // Do this separately from above so that the health bar doesn't go up and down.
332 
333  const t_translation::terrain_code terrain_dst = map.get_terrain(dst);
334  const terrain_type& terrain_dst_info = map.get_terrain_info(terrain_dst);
335 
336  int height_adjust_unit = static_cast<int>((terrain_info.unit_height_adjust() * (1.0 - adjusted_params.offset) +
337  terrain_dst_info.unit_height_adjust() * adjusted_params.offset) *
338  zoom_factor);
339  if (is_flying && height_adjust_unit < 0) {
340  height_adjust_unit = 0;
341  }
342  params.y -= height_adjust_unit - height_adjust;
343  params.halo_y -= height_adjust_unit - height_adjust;
344 
345  ac.anim_->redraw(params, halo_man);
346  ac.refreshing_ = false;
347 }
348 
349 void unit_drawer::draw_bar(const std::string& image, int xpos, int ypos,
350  const map_location& loc, std::size_t height, double filled,
351  const color_t& col, fixed_t alpha) const
352 {
353 
354  filled = std::min<double>(std::max<double>(filled,0.0),1.0);
355  height = static_cast<std::size_t>(height*zoom_factor);
356 
358 
359  // We use UNSCALED because scaling (and bilinear interpolation)
360  // is bad for calculate_energy_bar.
361  // But we will do a geometric scaling later.
362  surface bar_surf(image::get_image(image));
363  if(surf == nullptr || bar_surf == nullptr) {
364  return;
365  }
366 
367  // calculate_energy_bar returns incorrect results if the surface colors
368  // have changed (for example, due to bilinear interpolation)
369  const SDL_Rect& unscaled_bar_loc = calculate_energy_bar(bar_surf);
370 
371  SDL_Rect bar_loc;
372  if (surf->w == bar_surf->w && surf->h == bar_surf->h)
373  bar_loc = unscaled_bar_loc;
374  else {
375  const fixed_t xratio = fxpdiv(surf->w,bar_surf->w);
376  const fixed_t yratio = fxpdiv(surf->h,bar_surf->h);
377  const SDL_Rect scaled_bar_loc {
378  fxptoi(unscaled_bar_loc. x * xratio)
379  , fxptoi(unscaled_bar_loc. y * yratio + 127)
380  , fxptoi(unscaled_bar_loc. w * xratio + 255)
381  , fxptoi(unscaled_bar_loc. h * yratio + 255)
382  };
383  bar_loc = scaled_bar_loc;
384  }
385 
386  if(height > static_cast<std::size_t>(bar_loc.h)) {
387  height = bar_loc.h;
388  }
389 
390  //if(alpha != ftofxp(1.0)) {
391  // surf.assign(adjust_surface_alpha(surf,alpha));
392  // if(surf == nullptr) {
393  // return;
394  // }
395  //}
396 
397  const std::size_t skip_rows = bar_loc.h - height;
398 
399  SDL_Rect top {0, 0, surf->w, bar_loc.y};
400  SDL_Rect bot = sdl::create_rect(0, bar_loc.y + skip_rows, surf->w, 0);
401  bot.h = surf->w - bot.y;
402 
403  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos, ypos, surf, top);
404  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos, ypos + top.h, surf, bot);
405 
406  std::size_t unfilled = static_cast<std::size_t>(height * (1.0 - filled));
407 
408  if(unfilled < height && alpha >= ftofxp(0.3)) {
409  const uint8_t r_alpha = std::min<unsigned>(unsigned(fxpmult(alpha,255)),255);
410  surface filled_surf = create_compatible_surface(bar_surf, bar_loc.w, height - unfilled);
411  SDL_Rect filled_area = sdl::create_rect(0, 0, bar_loc.w, height-unfilled);
412  sdl::fill_surface_rect(filled_surf,&filled_area,SDL_MapRGBA(bar_surf->format,col.r,col.g,col.b, r_alpha));
413  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos + bar_loc.x, ypos + bar_loc.y + unfilled, filled_surf);
414  }
415 }
416 
418  bool operator()(uint32_t color) const { return (color&0xFF000000) > 0x10000000 &&
419  (color&0x00FF0000) < 0x00100000 &&
420  (color&0x0000FF00) < 0x00001000 &&
421  (color&0x000000FF) < 0x00000010; }
422 };
423 
424 const SDL_Rect& unit_drawer::calculate_energy_bar(surface surf) const
425 {
426  const std::map<surface,SDL_Rect>::const_iterator i = energy_bar_rects.find(surf);
427  if(i != energy_bar_rects.end()) {
428  return i->second;
429  }
430 
431  int first_row = -1, last_row = -1, first_col = -1, last_col = -1;
432 
434 
435  const_surface_lock image_lock(image);
436  const uint32_t* const begin = image_lock.pixels();
437 
438  for(int y = 0; y != image->h; ++y) {
439  const uint32_t* const i1 = begin + image->w*y;
440  const uint32_t* const i2 = i1 + image->w;
441  const uint32_t* const itor = std::find_if(i1,i2,is_energy_color());
442  const int count = std::count_if(itor,i2,is_energy_color());
443 
444  if(itor != i2) {
445  if(first_row == -1) {
446  first_row = y;
447  }
448 
449  first_col = itor - i1;
450  last_col = first_col + count;
451  last_row = y;
452  }
453  }
454 
455  const SDL_Rect res {
456  first_col
457  , first_row
458  , last_col-first_col
459  , last_row+1-first_row
460  };
461  energy_bar_rects.emplace(surf, res);
462  return calculate_energy_bar(surf);
463 }
surface get_image(const image::locator &i_locator, TYPE type)
function to get the surface corresponding to an image.
Definition: picture.cpp:1022
bool refreshing_
avoid infinite recursion. flag used for drawing / animation
pixel_t * pixels() const
Definition: surface.hpp:148
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:1365
bool rects_overlap(const SDL_Rect &rect1, const SDL_Rect &rect2)
Tests whether two rectangles overlap.
Definition: rect.cpp:33
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:64
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:1272
bool draw_bars_
bool indicating whether to draw bars with the unit
const config & get_cfg() const
Definition: types.hpp:269
#define h
std::string image_ellipse() const
Get the unit&#39;s ellipse image.
Definition: unit.hpp:1464
-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:763
bool get_hidden() const
Gets whether this unit is currently hidden on the map.
Definition: unit.hpp:669
double hp_bar_scaling() const
The factor by which the HP bar should be scaled.
Definition: unit.hpp:681
bool null() const
Definition: surface.hpp:79
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:1091
bool poisoned() const
Check if the unit has been poisoned.
Definition: unit.hpp:843
static const std::string & leader_crown()
The path to the leader crown overlay.
Definition: unit.cpp:1043
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:424
color_t xp_color() const
Color for this unit&#39;s XP.
Definition: unit.cpp:1101
#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:65
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:2358
const std::vector< std::string > & overlays() const
Get the unit&#39;s overlay images.
Definition: unit.hpp:1498
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:349
int32_t fixed_t
Definition: math.hpp:292
bool show_moved_orb()
Definition: general.cpp:270
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:741
bool invisible(const map_location &loc, bool see_all=true) const
Definition: unit.cpp:2381
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:1443
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:128
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:2424
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:690
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:1455
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:1178
void assign(SDL_Surface *surf)
Definition: surface.hpp:46
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:54
unit_drawer(display &thedisp)
Definition: drawer.cpp:35
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:1256
surface make_neutral_surface(const surface &surf)
Definition: utils.cpp:72
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
surface create_compatible_surface(const surface &surf, int width, int height)
Definition: utils.cpp:2099
bool incapacitated() const
Check if the unit has been petrified.
Definition: unit.hpp:852
halo::handle unit_halo_
handle to the halo of this unit
int total_movement() const
The maximum moves this unit has.
Definition: unit.hpp:1165
bool operator()(uint32_t color) const
Definition: drawer.cpp:418
bool emits_zoc() const
Tests whether the unit has a zone-of-control, considering incapacitated.
Definition: unit.hpp:1237
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:861
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:2532
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:1181
std::string image_mods() const
Gets an IPF string containing all IPF image mods.
Definition: unit.cpp:2537
std::string enemy_color()
Definition: general.cpp:323
static std::map< surface, SDL_Rect > energy_bar_rects
Definition: drawer.cpp:33
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