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