The Battle for Wesnoth  1.15.12+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 "color.hpp"
18 #include "display.hpp"
19 #include "display_context.hpp"
20 #include "formatter.hpp"
21 #include "game_display.hpp"
22 #include "halo.hpp"
23 #include "map/location.hpp"
24 #include "map/map.hpp"
25 #include "picture.hpp"
26 #include "preferences/game.hpp"
27 #include "sdl/surface.hpp"
28 #include "team.hpp"
29 #include "units/animation.hpp"
31 #include "units/frame.hpp"
32 #include "units/types.hpp"
33 #include "units/unit.hpp"
34 
35 // Map of different energy bar surfaces and their dimensions.
36 static std::map<surface, SDL_Rect> energy_bar_rects;
37 
38 namespace
39 {
40 /**
41  * Wrapper which will assemble the image path (including IPF for the color from get_orb_color) for a given orb.
42  * Returns nullptr if the preferences have been configured to hide this orb.
43  */
44 std::unique_ptr<image::locator> get_orb_image(orb_status os)
45 {
46  if(os == orb_status::disengaged) {
50  return std::make_unique<image::locator>(game_config::images::orb_two_color + "~RC(ellipse_red>"
51  + moved_color + ")~RC(magenta>" + partial_color + ")");
52  }
54  }
55 
57  return nullptr;
58  auto color = orb_status_helper::get_orb_color(os);
59  return std::make_unique<image::locator>(game_config::images::orb + "~RC(magenta>" + color + ")");
60 }
61 }
62 
64  disp(thedisp),
65  dc(disp.get_disp_context()),
66  map(dc.map()),
67  teams(dc.teams()),
68  halo_man(thedisp.get_halo_manager()),
69  viewing_team(disp.viewing_team()),
70  playing_team(disp.playing_team()),
71  viewing_team_ref(teams[viewing_team]),
72  playing_team_ref(teams[playing_team]),
73  is_blindfolded(disp.is_blindfolded()),
74  show_everything(disp.show_everything()),
75  sel_hex(disp.selected_hex()),
76  mouse_hex(disp.mouseover_hex()),
77  zoom_factor(disp.get_zoom_factor()),
78  hex_size(disp.hex_size()),
79  hex_size_by_2(disp.hex_size()/2)
80 {
81  if(const game_display* game_display = dynamic_cast<class game_display*>(&disp)) {
83  }
84 
85  // This used to be checked in the drawing code, where it simply triggered skipping some logic.
86  // However, I think it's obsolete, and that the initialization of viewing_team_ref would already
87  // be undefined behavior in the situation where this assert fails.
88  assert(disp.team_valid());
89 }
90 
91 void unit_drawer::redraw_unit (const unit & u) const
92 {
94  map_location loc = u.get_location();
95 
96  int side = u.side();
97 
98  bool hidden = u.get_hidden();
99  bool is_flying = u.is_flying();
100  map_location::DIRECTION facing = u.facing();
101  int hitpoints = u.hitpoints();
102  int max_hitpoints = u.max_hitpoints();
103 
104  bool can_recruit = u.can_recruit();
105  bool can_advance = u.can_advance();
106 
107  int experience = u.experience();
108  int max_experience = u.max_experience();
109 
110  bool emit_zoc = u.emits_zoc();
111 
112  color_t hp_color=u.hp_color();
113  color_t xp_color=u.xp_color();
114 
115  std::string ellipse=u.image_ellipse();
116 
117  const bool is_highlighted_enemy = units_that_can_reach_goal.count(loc) > 0;
118  const bool is_selected_hex = (loc == sel_hex || is_highlighted_enemy);
119 
121  ac.clear_haloes();
122  if(ac.anim_) {
123  ac.anim_->update_last_draw_time();
124  }
125  return;
126  }
127 
128  if (!ac.anim_) {
129  ac.set_standing();
130  if (!ac.anim_) return;
131  }
132 
133  if (ac.refreshing_) return;
134  ac.refreshing_ = true;
135 
136  ac.anim_->update_last_draw_time();
137  frame_parameters params;
138  const t_translation::terrain_code terrain = map.get_terrain(loc);
139  const terrain_type& terrain_info = map.get_terrain_info(terrain);
140 
141  // do not set to 0 so we can distinguish the flying from the "not on submerge terrain"
142  // instead use -1.0 (as in "negative depth", it will be ignored by rendering)
143  params.submerge= is_flying ? -1.0 : terrain_info.unit_submerge();
144 
145  if(u.invisible(loc) && params.highlight_ratio > 0.6) {
146  params.highlight_ratio = 0.6;
147  }
148  if (is_selected_hex && params.highlight_ratio == 1.0) {
149  params.highlight_ratio = 1.5;
150  }
151 
152  int height_adjust = static_cast<int>(terrain_info.unit_height_adjust() * zoom_factor);
153  if (is_flying && height_adjust < 0) {
154  height_adjust = 0;
155  }
156  params.y -= height_adjust;
157  params.halo_y -= height_adjust;
158 
159  int red = 0,green = 0,blue = 0,tints = 0;
160  double blend_ratio = 0;
161  // Add future colored states here
162  if(u.poisoned()) {
163  green += 255;
164  blend_ratio += 0.25;
165  tints += 1;
166  }
167  if(u.slowed()) {
168  red += 191;
169  green += 191;
170  blue += 255;
171  blend_ratio += 0.25;
172  tints += 1;
173  }
174  if(tints > 0) {
175  params.blend_with = color_t((red/tints),(green/tints),(blue/tints));
176  params.blend_ratio = ((blend_ratio/tints));
177  }
178 
179  //hackish : see unit_frame::merge_parameters
180  // we use image_mod on the primary image
181  // and halo_mod on secondary images and all haloes
182  params.image_mod = u.image_mods();
183  params.halo_mod = u.TC_image_mods();
184  params.image= u.default_anim_image();
185 
186 
187  if(u.incapacitated()) params.image_mod +="~GS()";
188  params.primary_frame = true;
189 
190 
191  const frame_parameters adjusted_params = ac.anim_->get_current_params(params);
192 
193  const map_location dst = loc.get_direction(facing);
194  const int xsrc = disp.get_location_x(loc);
195  const int ysrc = disp.get_location_y(loc);
196  const int xdst = disp.get_location_x(dst);
197  const int ydst = disp.get_location_y(dst);
198 
199  const int x = static_cast<int>(adjusted_params.offset * xdst + (1.0-adjusted_params.offset) * xsrc) + hex_size_by_2;
200  const int y = static_cast<int>(adjusted_params.offset * ydst + (1.0-adjusted_params.offset) * ysrc) + hex_size_by_2;
201 
202  bool has_halo = ac.unit_halo_ && ac.unit_halo_->valid();
203  if(!has_halo && !u.image_halo().empty()) {
204  ac.unit_halo_ = halo_man.add(x, y - height_adjust, u.image_halo()+u.TC_image_mods(), map_location(-1, -1));
205  }
206  if(has_halo && u.image_halo().empty()) {
208  ac.unit_halo_.reset();
209  } else if(has_halo) {
210  halo_man.set_location(ac.unit_halo_, x, y - height_adjust);
211  }
212 
213  // We draw bars only if wanted, visible on the map view
214  bool draw_bars = ac.draw_bars_ ;
215  if (draw_bars) {
216  SDL_Rect unit_rect {xsrc, ysrc +adjusted_params.y, hex_size, hex_size};
217  draw_bars = sdl::rects_overlap(unit_rect, disp.map_outside_area());
218  }
219  surface ellipse_front(nullptr);
220  surface ellipse_back(nullptr);
221  int ellipse_floating = 0;
222  // Always show the ellipse for selected units
223  if(draw_bars && (preferences::show_side_colors() || is_selected_hex)) {
224  if(adjusted_params.submerge > 0.0) {
225  // The division by 2 seems to have no real meaning,
226  // It just works fine with the current center of ellipse
227  // and prevent a too large adjust if submerge = 1.0
228  ellipse_floating = static_cast<int>(adjusted_params.submerge * hex_size_by_2);
229  }
230 
231  if(ellipse.empty()){
232  ellipse="misc/ellipse";
233  }
234 
235  if(ellipse != "none") {
236  // check if the unit has a ZoC or can recruit
237  const std::string nozoc = !emit_zoc ? "nozoc-" : "";
238  const std::string leader = can_recruit ? "leader-" : "";
239  const std::string selected = is_selected_hex? "selected-" : "";
240  const std::string tc = team::get_side_color_id(side);
241 
242  const std::string ellipse_top = formatter() << ellipse << "-" << leader << nozoc << selected << "top.png~RC(ellipse_red>" << tc << ")";
243  const std::string ellipse_bot = formatter() << ellipse << "-" << leader << nozoc << selected << "bottom.png~RC(ellipse_red>" << tc << ")";
244 
245  // Load the ellipse parts recolored to match team color
246  ellipse_back = image::get_image(image::locator(ellipse_top), image::SCALED_TO_ZOOM);
247  ellipse_front = image::get_image(image::locator(ellipse_bot), image::SCALED_TO_ZOOM);
248  }
249  }
250  if (ellipse_back != nullptr) {
251  //disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
253  xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
254  }
255 
256  if (ellipse_front != nullptr) {
257  //disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
259  xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
260  }
261  if(draw_bars) {
262  const auto& type_cfg = u.type().get_cfg();
263  const auto& cfg_offset_x = type_cfg["bar_offset_x"];
264  const auto& cfg_offset_y = type_cfg["bar_offset_y"];
265  int xoff;
266  int yoff;
267  if(cfg_offset_x.empty() && cfg_offset_y.empty()) {
269  xoff = !unit_img ? 0 : (hex_size - unit_img->w)/2;
270  yoff = !unit_img ? 0 : (hex_size - unit_img->h)/2;
271  }
272  else {
273  xoff = cfg_offset_x.to_int();
274  yoff = cfg_offset_y.to_int();
275  }
276 
277  const std::string* energy_file = &game_config::images::energy;
278 
279  using namespace orb_status_helper;
280  std::unique_ptr<image::locator> orb_img = nullptr;
281  if(viewing_team_ref.is_enemy(side)) {
282  if(!u.incapacitated())
283  orb_img = get_orb_image(orb_status::enemy);
284  } else if(static_cast<std::size_t>(side) != playing_team + 1) {
285  // We're looking at either the player's own unit or an ally's unit, but either way it
286  // doesn't belong to the playing_team and isn't expected to move until after its next
287  // turn refresh.
288  auto os = orb_status::moved;
289  if(static_cast<std::size_t>(side) != viewing_team + 1)
290  os = orb_status::allied;
291  orb_img = get_orb_image(os);
292  } else {
293  // We're looking at either the player's own unit, or an ally's unit, during the unit's
294  // owner's turn.
295  auto os = dc.unit_orb_status(u);
296  orb_img = get_orb_image(os);
297  }
298 
299  if(orb_img != nullptr) {
301  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xsrc + xoff, ysrc + yoff + adjusted_params.y, orb);
302  }
303 
304  double unit_energy = 0.0;
305  if(max_hitpoints > 0) {
306  unit_energy = static_cast<double>(hitpoints)/static_cast<double>(max_hitpoints);
307  }
308  const int bar_shift = static_cast<int>(-5*zoom_factor);
309  const int hp_bar_height = static_cast<int>(max_hitpoints * u.hp_bar_scaling());
310 
311  const fixed_t bar_alpha = (loc == mouse_hex || is_selected_hex) ? ftofxp(1.0): ftofxp(0.8);
312 
313  draw_bar(*energy_file, xsrc+xoff+bar_shift, ysrc+yoff+adjusted_params.y,
314  loc, hp_bar_height, unit_energy,hp_color, bar_alpha);
315 
316  if(experience > 0 && can_advance) {
317  const double filled = static_cast<double>(experience) / static_cast<double>(max_experience);
318  const int xp_bar_height = static_cast<int>(max_experience * u.xp_bar_scaling() / std::max<int>(u.level(),1));
319 
320  draw_bar(*energy_file, xsrc+xoff, ysrc+yoff+adjusted_params.y,
321  loc, xp_bar_height, filled, xp_color, bar_alpha);
322  }
323 
324  if (can_recruit) {
326  if(crown) {
327  //if(bar_alpha != ftofxp(1.0)) {
328  // crown = adjust_surface_alpha(crown, bar_alpha);
329  //}
331  loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, crown);
332  }
333  }
334 
335  for(const std::string& ov : u.overlays()) {
337  if(ov_img != nullptr) {
339  loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, ov_img);
340  }
341  }
342  }
343 
344  // Smooth unit movements from terrain of different elevation.
345  // Do this separately from above so that the health bar doesn't go up and down.
346 
347  const t_translation::terrain_code terrain_dst = map.get_terrain(dst);
348  const terrain_type& terrain_dst_info = map.get_terrain_info(terrain_dst);
349 
350  int height_adjust_unit = static_cast<int>((terrain_info.unit_height_adjust() * (1.0 - adjusted_params.offset) +
351  terrain_dst_info.unit_height_adjust() * adjusted_params.offset) *
352  zoom_factor);
353  if (is_flying && height_adjust_unit < 0) {
354  height_adjust_unit = 0;
355  }
356  params.y -= height_adjust_unit - height_adjust;
357  params.halo_y -= height_adjust_unit - height_adjust;
358 
359  ac.anim_->redraw(params, halo_man);
360  ac.refreshing_ = false;
361 }
362 
363 void unit_drawer::draw_bar(const std::string& image, int xpos, int ypos,
364  const map_location& loc, std::size_t height, double filled,
365  const color_t& col, fixed_t alpha) const
366 {
367 
368  filled = std::min<double>(std::max<double>(filled,0.0),1.0);
369  height = static_cast<std::size_t>(height*zoom_factor);
370 
372 
373  // We use UNSCALED because scaling (and bilinear interpolation)
374  // is bad for calculate_energy_bar.
375  // But we will do a geometric scaling later.
376  surface bar_surf(image::get_image(image));
377  if(surf == nullptr || bar_surf == nullptr) {
378  return;
379  }
380 
381  // calculate_energy_bar returns incorrect results if the surface colors
382  // have changed (for example, due to bilinear interpolation)
383  const SDL_Rect& unscaled_bar_loc = calculate_energy_bar(bar_surf);
384 
385  SDL_Rect bar_loc;
386  if (surf->w == bar_surf->w && surf->h == bar_surf->h)
387  bar_loc = unscaled_bar_loc;
388  else {
389  const fixed_t xratio = fxpdiv(surf->w,bar_surf->w);
390  const fixed_t yratio = fxpdiv(surf->h,bar_surf->h);
391  const SDL_Rect scaled_bar_loc {
392  fxptoi(unscaled_bar_loc. x * xratio)
393  , fxptoi(unscaled_bar_loc. y * yratio + 127)
394  , fxptoi(unscaled_bar_loc. w * xratio + 255)
395  , fxptoi(unscaled_bar_loc. h * yratio + 255)
396  };
397  bar_loc = scaled_bar_loc;
398  }
399 
400  if(height > static_cast<std::size_t>(bar_loc.h)) {
401  height = bar_loc.h;
402  }
403 
404  //if(alpha != ftofxp(1.0)) {
405  // surf.assign(adjust_surface_alpha(surf,alpha));
406  // if(surf == nullptr) {
407  // return;
408  // }
409  //}
410 
411  const std::size_t skip_rows = bar_loc.h - height;
412 
413  SDL_Rect top {0, 0, surf->w, bar_loc.y};
414  SDL_Rect bot = sdl::create_rect(0, bar_loc.y + skip_rows, surf->w, 0);
415  bot.h = surf->w - bot.y;
416 
417  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos, ypos, surf, top);
418  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos, ypos + top.h, surf, bot);
419 
420  std::size_t unfilled = static_cast<std::size_t>(height * (1.0 - filled));
421 
422  if(unfilled < height && alpha >= ftofxp(0.3)) {
423  const uint8_t r_alpha = std::min<unsigned>(unsigned(fxpmult(alpha,255)),255);
424  surface filled_surf(bar_loc.w, height - unfilled);
425  SDL_Rect filled_area = sdl::create_rect(0, 0, bar_loc.w, height-unfilled);
426  sdl::fill_surface_rect(filled_surf,&filled_area,SDL_MapRGBA(bar_surf->format,col.r,col.g,col.b, r_alpha));
427  disp.drawing_buffer_add(display::LAYER_UNIT_BAR, loc, xpos + bar_loc.x, ypos + bar_loc.y + unfilled, filled_surf);
428  }
429 }
430 
432  bool operator()(uint32_t color) const { return (color&0xFF000000) > 0x10000000 &&
433  (color&0x00FF0000) < 0x00100000 &&
434  (color&0x0000FF00) < 0x00001000 &&
435  (color&0x000000FF) < 0x00000010; }
436 };
437 
438 const SDL_Rect& unit_drawer::calculate_energy_bar(surface surf) const
439 {
440  const std::map<surface,SDL_Rect>::const_iterator i = energy_bar_rects.find(surf);
441  if(i != energy_bar_rects.end()) {
442  return i->second;
443  }
444 
445  int first_row = -1, last_row = -1, first_col = -1, last_col = -1;
446 
447  const_surface_lock image_lock(surf);
448  const uint32_t* const begin = image_lock.pixels();
449 
450  for(int y = 0; y != surf->h; ++y) {
451  const uint32_t* const i1 = begin + surf->w*y;
452  const uint32_t* const i2 = i1 + surf->w;
453  const uint32_t* const itor = std::find_if(i1,i2,is_energy_color());
454  const int count = std::count_if(itor,i2,is_energy_color());
455 
456  if(itor != i2) {
457  if(first_row == -1) {
458  first_row = y;
459  }
460 
461  first_col = itor - i1;
462  last_col = first_col + count;
463  last_row = y;
464  }
465  }
466 
467  const SDL_Rect res {
468  first_col
469  , first_row
470  , last_col-first_col
471  , last_row+1-first_row
472  };
473  energy_bar_rects.emplace(surf, res);
474  return calculate_energy_bar(surf);
475 }
surface get_image(const image::locator &i_locator, TYPE type)
Caches and returns an image.
Definition: picture.cpp:815
bool refreshing_
avoid infinite recursion.
pixel_t * pixels() const
Definition: surface.hpp:161
Reserve layers to be selected for WML.
Definition: display.hpp:831
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
std::optional< color_t > blend_with
Definition: frame.hpp:54
This class represents a single unit of a specific type.
Definition: unit.hpp:120
#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:1457
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:137
int hitpoints() const
The current number of hitpoints this unit has.
Definition: unit.hpp:492
Frame for unit&#39;s animation sequence.
int hex_size
Definition: drawer.hpp:65
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:49
const terrain_type & get_terrain_info(const t_translation::terrain_code &terrain) const
Definition: map.cpp:97
map_location::DIRECTION facing() const
The current direction this unit is facing within its hex.
Definition: unit.hpp:1364
bool draw_bars_
bool indicating whether to draw bars with the unit
const config & get_cfg() const
Definition: types.hpp:276
#define h
Belongs to a friendly side.
std::string image_ellipse() const
Get the unit&#39;s ellipse image.
Definition: unit.hpp:1556
bool show_side_colors()
Definition: game.cpp:754
orb_status
Corresponds to the colored orbs displayed above units&#39; hp-bar and xp-bar.
Definition: orb_status.hpp:23
bool get_hidden() const
Gets whether this unit is currently hidden on the map.
Definition: unit.hpp:713
double hp_bar_scaling() const
The factor by which the HP bar should be scaled.
Definition: unit.hpp:725
map_location get_direction(DIRECTION dir, unsigned int n=1u) const
Definition: location.cpp:359
bool team_valid() const
Definition: display.cpp:734
const unit_type & type() const
This unit&#39;s type, accounting for gender and variation.
Definition: unit.hpp:345
color_t hp_color() const
Color for this unit&#39;s current hitpoints.
Definition: unit.cpp:1045
bool poisoned() const
Check if the unit has been poisoned.
Definition: unit.hpp:887
Belongs to a non-friendly side; normally visualised by not displaying an orb.
static const std::string & leader_crown()
The path to the leader crown overlay.
Definition: unit.cpp:997
void clear_haloes()
Clear the haloes associated to the unit.
int unit_height_adjust() const
Definition: terrain.hpp:136
#define fxpmult(x, y)
IN: unsigned and fixed_t - OUT: unsigned.
Definition: math.hpp:320
std::string halo_mod
Definition: frame.hpp:49
std::ostringstream wrapper.
Definition: formatter.hpp:38
std::string get_orb_color(orb_status os)
Wrapper for the various preferences::unmoved_color(), moved_color(), etc methods, using the enum inst...
Definition: orb_status.cpp:39
terrain_code get_terrain(const map_location &loc) const
Looks up terrain at a particular location.
Definition: map.cpp:297
const SDL_Rect & calculate_energy_bar(surface surf) const
Finds the start and end rows on the energy bar image.
Definition: drawer.cpp:438
color_t xp_color() const
Color for this unit&#39;s XP.
Definition: unit.cpp:1099
#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:856
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:522
uint8_t r
Red value.
Definition: color.hpp:177
bool is_enemy(int n) const
Definition: team.hpp:251
int level() const
The current level of this unit.
Definition: unit.hpp:552
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:2362
const std::vector< std::string > & overlays() const
Get the unit&#39;s overlay images.
Definition: unit.hpp:1590
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:363
int32_t fixed_t
Definition: math.hpp:312
std::set< map_location > units_that_can_reach_goal
Definition: drawer.hpp:63
Generic locator abstracting the location of an image.
Definition: picture.hpp:59
static std::string get_side_color_id(unsigned side)
Definition: team.cpp:959
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
Image rescaled according to the zoom settings.
Definition: picture.hpp:233
Encapsulates the map of the game.
Definition: location.hpp:37
bool invisible(const map_location &loc, bool see_all=true) const
Definition: unit.cpp:2380
double highlight_ratio
Definition: frame.hpp:57
std::size_t i
Definition: function.cpp:940
unit_animation_component & anim_comp() const
Definition: unit.hpp:1535
int max_hitpoints() const
The max number of hitpoints this unit can have.
Definition: unit.hpp:498
std::string moved_color()
Definition: general.cpp:337
std::string image_mod
Definition: frame.hpp:43
Helper class for pinning SDL surfaces into memory.
Definition: surface.hpp:141
bool can_recruit() const
Whether this unit can recruit other units - ie, are they a leader unit.
Definition: unit.hpp:605
int get_location_y(const map_location &loc) const
Definition: display.cpp:754
const SDL_Rect & map_outside_area() const
Returns the available area for a map, this may differ from the above.
Definition: display.hpp:240
const team & viewing_team_ref
Definition: drawer.hpp:56
DIRECTION
Valid directions which can be moved in our hexagonal world.
Definition: location.hpp:39
const display_context & dc
Definition: drawer.hpp:50
int w
All moves and possible attacks have been done.
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:2423
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:734
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:1547
std::string partial_color()
Definition: general.cpp:357
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:1208
int get_location_x(const map_location &loc) const
Functions to get the on-screen positions of hexes.
Definition: display.cpp:749
Image rescaled to fit into a hexagonal tile according to the zoom settings.
Definition: picture.hpp:237
void redraw_unit(const unit &u) const
draw a unit.
Definition: drawer.cpp:91
unit_drawer(display &thedisp)
Definition: drawer.cpp:63
int experience() const
The current number of experience points this unit has.
Definition: unit.hpp:516
orb_status unit_orb_status(const unit &u) const
Returns an enumurated summary of whether this unit can move and/or attack.
const map_location & get_location() const
The current map location this unit is at.
Definition: unit.hpp:1348
Functions to load and save images from/to disk.
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:896
The unit can move but can&#39;t attack, and wouldn&#39;t be able to attack even if it was moved to a hex adja...
halo::handle unit_halo_
handle to the halo of this unit
bool operator()(uint32_t color) const
Definition: drawer.cpp:432
bool emits_zoc() const
Tests whether the unit has a zone-of-control, considering incapacitated.
Definition: unit.hpp:1329
int side() const
The side this unit belongs to.
Definition: unit.hpp:333
bool prefs_show_orb(orb_status os)
Wrapper for the various preferences::show_..._orb() methods, using the enum instead of exposing a sep...
Definition: orb_status.cpp:18
void set_standing(bool with_bars=true)
Sets the animation state to standing.
std::size_t playing_team
Definition: drawer.hpp:55
There are still moves and/or attacks possible, but the unit doesn&#39;t fit in the "unmoved" status...
uint8_t g
Green value.
Definition: color.hpp:180
std::string orb_two_color
uint8_t b
Blue value.
Definition: color.hpp:183
bool slowed() const
Check if the unit has been slowed.
Definition: unit.hpp:905
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:2531
boost::tribool primary_frame
Definition: frame.hpp:68
std::string image_mods() const
Gets an IPF string containing all IPF image mods.
Definition: unit.cpp:2536
static std::map< surface, SDL_Rect > energy_bar_rects
Definition: drawer.cpp:36
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