The Battle for Wesnoth  1.19.3+dev
game_display.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2024
3  by David White <dave@whitevine.net>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 /**
17  * @file
18  * During a game, show map & info-panels at top+right.
19  */
20 
21 #include "game_display.hpp"
22 
23 
24 #include "cursor.hpp"
25 #include "display_chat_manager.hpp"
26 #include "fake_unit_manager.hpp"
27 #include "floating_label.hpp"
28 #include "game_board.hpp"
30 #include "log.hpp"
31 #include "map/map.hpp"
32 #include "font/standard_colors.hpp"
33 #include "reports.hpp"
34 #include "resources.hpp"
35 #include "tod_manager.hpp"
36 #include "color.hpp"
37 #include "synced_context.hpp"
38 #include "units/unit.hpp"
39 #include "units/drawer.hpp"
40 #include "utils/general.hpp"
41 #include "whiteboard/manager.hpp"
42 #include "overlay.hpp"
43 #include "draw.hpp"
44 
45 static lg::log_domain log_display("display");
46 #define ERR_DP LOG_STREAM(err, log_display)
47 #define LOG_DP LOG_STREAM(info, log_display)
48 #define DBG_DP LOG_STREAM(debug, log_display)
49 
50 static lg::log_domain log_engine("engine");
51 #define ERR_NG LOG_STREAM(err, log_engine)
52 
53 std::map<map_location, int> game_display::debugHighlights_;
54 
55 /**
56  * Function to return 2 half-hex footsteps images for the given location.
57  * Only loc is on the current route set by set_route.
58  *
59  * This function is only used internally by game_display so I have moved it out of the header into the compilaton unit.
60  */
61 std::vector<texture> footsteps_images(const map_location& loc, const pathfind::marked_route & route_, const display_context * dc_);
62 
64  std::weak_ptr<wb::manager> wb,
65  reports& reports_object,
66  const std::string& theme_id,
67  const config& level)
68  : display(&board, wb, reports_object, theme_id, level)
69  , overlay_map_()
70  , attack_indicator_src_()
71  , attack_indicator_dst_()
72  , route_()
73  , displayedUnitHex_()
74  , first_turn_(true)
75  , in_game_(false)
76  , chat_man_(new display_chat_manager(*this))
77  , mode_(RUNNING)
78  , needs_rebuild_(false)
79 {
80 }
81 
83 {
84  try {
85  chat_man_->prune_chat_messages(true);
86  } catch(...) {
87  DBG_DP << "Caught exception in game_display destructor: " << utils::get_unknown_exception_type();
88  }
89 }
90 
92 {
93  if(!first_turn_) {
96 
97  if(old_tod.image_mask != tod.image_mask) {
98  fade_tod_mask(old_tod.image_mask, tod.image_mask);
99  }
100  }
101 
102  first_turn_ = false;
103 
104  update_tod();
105 }
106 
108 {
109  if(hex.valid() && fogged(hex)) {
110  return;
111  }
112  display::select_hex(hex);
113 
114  display_unit_hex(hex);
115 }
116 
118 {
119  wb::future_map_if future(!synced_context::is_synced()); /**< Lasts for whole method. */
120 
121  const unit *u = dc_->get_visible_unit(hex, viewing_team(), !dont_show_all_);
122  if (u) {
123  displayedUnitHex_ = hex;
124  invalidate_unit();
125  } else {
127  if (u) {
128  // mouse moved from unit hex to non-unit hex
129  if (dc_->units().count(selectedHex_)) {
131  invalidate_unit();
132  }
133  }
134  }
135 
138 }
139 
140 
142 {
143  if (!hex.valid())
144  return;
145 
146  wb::future_map_if future(!synced_context::is_synced()); /**< Lasts for whole method. */
147 
148  const unit *u = dc_->get_visible_unit(hex, viewing_team(), !dont_show_all_);
149  if (u) {
150  displayedUnitHex_ = hex;
151  invalidate_unit();
152  }
153 }
154 
156 {
157  if (src == displayedUnitHex_) {
159  invalidate_unit();
160  }
161 }
162 
163 void game_display::scroll_to_leader(int side, SCROLL_TYPE scroll_type,bool force)
164 {
165  unit_map::const_iterator leader = dc_->units().find_leader(side);
166 
167  if(leader.valid() && leader->is_visible_to_team(viewing_team(), false)) {
168  scroll_to_tile(leader->get_location(), scroll_type, true, force);
169  }
170 }
171 
173 {
174  display::update();
175 
176  if (std::shared_ptr<wb::manager> w = wb_.lock()) {
177  w->pre_draw();
178  }
180  /**
181  * @todo FIXME: must modify changed, but best to do it at the
182  * floating_label level
183  */
184  chat_man_->prune_chat_messages();
185 }
186 
187 
189 {
190  display::render();
191 
192  if (std::shared_ptr<wb::manager> w = wb_.lock()) {
193  w->post_draw();
194  }
195 }
196 
198 {
200  if (fake_unit_man_->empty()) {
201  return;
202  }
203  unit_drawer drawer = unit_drawer(*this);
204 
205  for (const unit* temp_unit : *fake_unit_man_) {
206  const map_location& loc = temp_unit->get_location();
208  if (invalidated_.find(loc) != invalidated_.end()
209  && (request == exclusive_unit_draw_requests_.end() || request->second == temp_unit->id()))
210  drawer.redraw_unit(*temp_unit);
211  }
212 }
213 
214 namespace
215 {
216 const std::string mouseover_normal_top = "misc/hover-hex-top.png~RC(magenta>gold)";
217 const std::string mouseover_normal_bot = "misc/hover-hex-bottom.png~RC(magenta>gold)";
218 
219 const std::string mouseover_enemy_top = "misc/hover-hex-enemy-top.png~RC(magenta>red)";
220 const std::string mouseover_enemy_bot = "misc/hover-hex-enemy-bottom.png~RC(magenta>red)";
221 
222 const std::string mouseover_self_top = "misc/hover-hex-top.png~RC(magenta>green)";
223 const std::string mouseover_self_bot = "misc/hover-hex-bottom.png~RC(magenta>green)";
224 
225 const std::string mouseover_ally_top = "misc/hover-hex-top.png~RC(magenta>lightblue)";
226 const std::string mouseover_ally_bot = "misc/hover-hex-bottom.png~RC(magenta>lightblue)";
227 }
228 
230 {
231  const bool on_map = get_map().on_board(loc);
232  const bool is_shrouded = shrouded(loc);
233 
234  display::draw_hex(loc);
235 
236  if(cursor::get() == cursor::WAIT) {
237  // Interaction is disabled, so we don't need anything else
238  return;
239  }
240 
241  if(on_map && loc == mouseoverHex_ && !map_screenshot_) {
243  const unit* u = dc_->get_visible_unit(loc, viewing_team());
244  if(u != nullptr) {
245  hex_top_layer = drawing_layer::mouseover_top;
246  }
247 
248  const std::string* mo_top_path;
249  const std::string* mo_bot_path;
250 
251  if(u == nullptr) {
252  mo_top_path = &mouseover_normal_top;
253  mo_bot_path = &mouseover_normal_bot;
254  } else if(viewing_team().is_enemy(u->side())) {
255  mo_top_path = &mouseover_enemy_top;
256  mo_bot_path = &mouseover_enemy_bot;
257  } else if(viewing_team().side() == u->side()) {
258  mo_top_path = &mouseover_self_top;
259  mo_bot_path = &mouseover_self_bot;
260  } else {
261  mo_top_path = &mouseover_ally_top;
262  mo_bot_path = &mouseover_ally_bot;
263  }
264 
265  drawing_buffer_add(hex_top_layer, loc,
266  [tex = image::get_texture(*mo_top_path, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
267 
269  [tex = image::get_texture(*mo_bot_path, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
270  }
271 
272  // Draw reach_map information.
273  // We remove the reachability mask of the unit that we want to attack.
274  if(!is_shrouded && !reach_map_.empty() && reach_map_.find(loc) == reach_map_.end() && loc != attack_indicator_dst_) {
277  [tex = image::get_texture(unreachable, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
278  }
279 
280  if(std::shared_ptr<wb::manager> w = wb_.lock()) {
281  w->draw_hex(loc);
282 
283  if(!(w->is_active() && w->has_temp_move())) {
284  std::vector<texture> footstepImages = footsteps_images(loc, route_, dc_);
285  if(!footstepImages.empty()) {
286  drawing_buffer_add(drawing_layer::footsteps, loc, [images = std::move(footstepImages)](const rect& dest) {
287  for(const texture& t : images) {
288  draw::blit(t, dest);
289  }
290  });
291  }
292  }
293  }
294 
295  // Draw the attack direction indicator
296  if(on_map && loc == attack_indicator_src_) {
298  [tex = image::get_texture("misc/attack-indicator-src-" + attack_indicator_direction() + ".png", image::HEXED)](const rect& dest)
299  { draw::blit(tex, dest); }
300  );
301  } else if(on_map && loc == attack_indicator_dst_) {
303  [tex = image::get_texture("misc/attack-indicator-dst-" + attack_indicator_direction() + ".png", image::HEXED)](const rect& dest)
304  { draw::blit(tex, dest); }
305  );
306  }
307 
308  // Linger overlay unconditionally otherwise it might give glitches
309  // so it's drawn over the shroud and fog.
310  if(mode_ != RUNNING) {
313  [tex = image::get_texture(linger, image::TOD_COLORED)](const rect& dest) { draw::blit(tex, dest); });
314  }
315 
316  if(on_map && loc == selectedHex_ && !game_config::images::selected.empty()) {
319  [tex = image::get_texture(selected, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
320  }
321 
322  // Show def% and turn to reach info
323  if(!is_shrouded && on_map) {
324  draw_movement_info(loc);
325  }
326 
327  if(game_config::debug) {
328  int debugH = debugHighlights_[loc];
329  if (debugH) {
330  std::string txt = std::to_string(debugH);
332  }
333  }
334 }
335 
337 {
339 }
340 
342 {
344 }
345 
347 {
348  display::layout();
349 
350  refresh_report("report_clock");
351  refresh_report("report_battery");
352  refresh_report("report_countdown");
353 
355  {
356  wb::future_map future; // start planned unit map scope
357 
358  // We display the unit the mouse is over if it is over a unit,
359  // otherwise we display the unit that is selected.
360  for (const std::string &name : reports_object_->report_list()) {
361  refresh_report(name);
362  }
363  invalidateGameStatus_ = false;
364  }
365 }
366 
367 
369 {
370  if(mode != mode_) {
371  mode_ = mode;
372  invalidate_all();
373  }
374 }
375 
377 {
378  // Search if there is a mark here
380 
381  std::shared_ptr<wb::manager> wb = wb_.lock();
382 
383  // Don't use empty route or the first step (the unit will be there)
384  if(w != route_.marks.end()
385  && !route_.steps.empty() && route_.steps.front() != loc) {
386  const unit_map::const_iterator un =
387  (wb && wb->get_temp_move_unit().valid()) ?
388  wb->get_temp_move_unit() : dc_->units().find(route_.steps.front());
389  if(un != dc_->units().end()) {
390  // Display the def% of this terrain
391  int move_cost = un->movement_cost(get_map().get_terrain(loc));
392  int def = (move_cost == movetype::UNREACHABLE ?
393  0 : 100 - un->defense_modifier(get_map().get_terrain(loc)));
394  std::stringstream def_text;
395  def_text << def << "%";
396 
397  color_t color = game_config::red_to_green(def, false);
398 
399  // simple mark (no turn point) use smaller font
400  int def_font = w->second.turns > 0 ? 18 : 16;
401  draw_text_in_hex(loc, drawing_layer::move_info, def_text.str(), def_font, color);
402 
404  [inv = w->second.invisible, zoc = w->second.zoc, cap = w->second.capture](const rect& dest) {
405  if(inv) {
406  draw::blit(image::get_texture(image::locator{"misc/hidden.png"}, image::HEXED), dest);
407  }
408 
409  if(zoc) {
410  draw::blit(image::get_texture(image::locator{"misc/zoc.png"}, image::HEXED), dest);
411  }
412 
413  if(cap) {
414  draw::blit(image::get_texture(image::locator{"misc/capture.png"}, image::HEXED), dest);
415  }
416  });
417 
418  //we display turn info only if different from a simple last "1"
419  if (w->second.turns > 1 || (w->second.turns == 1 && loc != route_.steps.back())) {
420  std::stringstream turns_text;
421  turns_text << w->second.turns;
422  draw_text_in_hex(loc, drawing_layer::move_info, turns_text.str(), 17, font::NORMAL_COLOR, 0.5,0.8);
423  }
424 
425  // The hex is full now, so skip the "show enemy moves"
426  return;
427  }
428  }
429  // When out-of-turn, it's still interesting to check out the terrain defs of the selected unit
430  else if (selectedHex_.valid() && loc == mouseoverHex_)
431  {
432  const unit_map::const_iterator selectedUnit = resources::gameboard->find_visible_unit(selectedHex_,viewing_team());
433  const unit_map::const_iterator mouseoveredUnit = resources::gameboard->find_visible_unit(mouseoverHex_,viewing_team());
434  if(selectedUnit != dc_->units().end() && mouseoveredUnit == dc_->units().end()) {
435  // Display the def% of this terrain
436  int move_cost = selectedUnit->movement_cost(get_map().get_terrain(loc));
437  int def = (move_cost == movetype::UNREACHABLE ?
438  0 : 100 - selectedUnit->defense_modifier(get_map().get_terrain(loc)));
439  std::stringstream def_text;
440  def_text << def << "%";
441 
442  color_t color = game_config::red_to_green(def, false);
443 
444  // use small font
445  int def_font = 16;
446  draw_text_in_hex(loc, drawing_layer::move_info, def_text.str(), def_font, color);
447  }
448  }
449 
450  if (!reach_map_.empty()) {
451  reach_map::iterator reach = reach_map_.find(loc);
452  if (reach != reach_map_.end() && reach->second > 1) {
453  const std::string num = std::to_string(reach->second);
454  draw_text_in_hex(loc, drawing_layer::move_info, num, 16, font::YELLOW_COLOR);
455  }
456  }
457 }
458 
459 std::vector<texture> footsteps_images(const map_location& loc, const pathfind::marked_route & route_, const display_context * dc_)
460 {
461  std::vector<texture> res;
462 
463  if (route_.steps.size() < 2) {
464  return res; // no real "route"
465  }
466 
467  std::vector<map_location>::const_iterator i =
468  std::find(route_.steps.begin(),route_.steps.end(),loc);
469 
470  if( i == route_.steps.end()) {
471  return res; // not on the route
472  }
473 
474  // Check which footsteps images of game_config we will use
475  int move_cost = 1;
476  const unit_map::const_iterator u = dc_->units().find(route_.steps.front());
477  if(u != dc_->units().end()) {
478  move_cost = u->movement_cost(dc_->map().get_terrain(loc));
479  }
480  int image_number = std::min<int>(move_cost, game_config::foot_speed_prefix.size());
481  if (image_number < 1) {
482  return res; // Invalid movement cost or no images
483  }
484  const std::string foot_speed_prefix = game_config::foot_speed_prefix[image_number-1];
485 
486  texture teleport;
487 
488  // We draw 2 half-hex (with possibly different directions),
489  // but skip the first for the first step.
490  const int first_half = (i == route_.steps.begin()) ? 1 : 0;
491  // and the second for the last step
492  const int second_half = (i+1 == route_.steps.end()) ? 0 : 1;
493 
494  for (int h = first_half; h <= second_half; ++h) {
495  const std::string sense( h==0 ? "-in" : "-out" );
496 
497  if (!tiles_adjacent(*(i+(h-1)), *(i+h))) {
498  std::string teleport_image =
500  teleport = image::get_texture(teleport_image, image::HEXED);
501  continue;
502  }
503 
504  // In function of the half, use the incoming or outgoing direction
505  map_location::DIRECTION dir = (i+(h-1))->get_relative_dir(*(i+h));
506 
507  std::string rotate;
508  if (dir > map_location::SOUTH_EAST) {
509  // No image, take the opposite direction and do a 180 rotation
510  dir = i->get_opposite_dir(dir);
511  rotate = "~FL(horiz)~FL(vert)";
512  }
513 
514  const std::string image = foot_speed_prefix
515  + sense + "-" + i->write_direction(dir)
516  + ".png" + rotate;
517 
518  res.push_back(image::get_texture(image, image::HEXED));
519  }
520 
521  // we draw teleport image (if any) in last
522  if (teleport != nullptr) res.push_back(teleport);
523 
524  return res;
525 }
526 
527 
528 
530 {
532  highlight_another_reach(paths_list);
533 }
534 
536  const map_location& goal)
537 {
538  // Fold endpoints of routes into reachability map.
539  for (const pathfind::paths::step &dest : paths_list.destinations) {
540  reach_map_[dest.curr]++;
541  }
542  reach_map_changed_ = true;
543 
544  if(goal != map_location::null_location() && paths_list.destinations.contains(goal)) {
545  const auto& path_to_goal = paths_list.destinations.get_path(paths_list.destinations.find(goal));
546  const map_location enemy_unit_location = path_to_goal[0];
547  units_that_can_reach_goal_.insert(enemy_unit_location);
548  }
549 }
550 
552 {
554  if(!reach_map_.empty()) {
555  reach_map_.clear();
556  reach_map_changed_ = true;
557  return true;
558  } else {
559  return false;
560  }
561 }
562 
564 {
565  for(std::vector<map_location>::const_iterator i = route_.steps.begin();
566  i != route_.steps.end(); ++i) {
567  invalidate(*i);
568  }
569 }
570 
572 {
574 
575  if(route != nullptr) {
576  route_ = *route;
577  } else {
578  route_.steps.clear();
579  route_.marks.clear();
580  }
581 
583 }
584 
585 void game_display::float_label(const map_location& loc, const std::string& text, const color_t& color)
586 {
587  if(prefs::get().floating_labels() == false || fogged(loc)) {
588  return;
589  }
590 
591  font::floating_label flabel(text);
593  flabel.set_color(color);
594  flabel.set_position(get_location_x(loc)+zoom_/2, get_location_y(loc));
595  flabel.set_move(0, -0.1 * turbo_speed() * get_zoom_factor());
596  flabel.set_lifetime(1000/turbo_speed());
598 
599  font::add_floating_label(flabel);
600 }
601 
603 {
604  assert(game_config::debug);
605  return debugHighlights_[loc];
606 }
607 
609 {
613 
616 
619  }
620 }
621 
623 {
625 }
626 
628 {
629  return viewing_team().team_name();
630 }
631 
633 {
634  in_game_ = true;
635  create_buttons();
636  invalidate_all();
637 }
638 
640  if (b) {
641  needs_rebuild_ = true;
642  }
643 }
644 
646  if (needs_rebuild_) {
647  needs_rebuild_ = false;
649  invalidate_all();
650  rebuild_all();
651  return true;
652  }
653  return false;
654 }
655 
657 {
658  return overlay_map_;
659 }
const std::vector< map_location > & route_
Definition: move.cpp:300
double t
Definition: astarsearch.cpp:63
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:159
Abstract class for exposing game data that doesn't depend on the GUI, however which for historical re...
const unit * get_visible_unit(const map_location &loc, const team &current_team, bool see_all=false) const
virtual const gamemap & map() const =0
virtual const unit_map & units() const =0
Sort-of-Singleton that many classes, both GUI and non-GUI, use to access the game data.
Definition: display.hpp:89
const team & viewing_team() const
Definition: display.cpp:342
bool map_screenshot_
Used to indicate to drawing functions that we are doing a map screenshot.
Definition: display.hpp:887
void draw_text_in_hex(const map_location &loc, const drawing_layer layer, const std::string &text, std::size_t font_size, color_t color, double x_in_hex=0.5, double y_in_hex=0.5)
Draw text on a hex.
Definition: display.cpp:1447
std::map< map_location, std::vector< overlay > > overlay_map
Definition: display.hpp:907
map_location selectedHex_
Definition: display.hpp:786
void recalculate_minimap()
Schedule the minimap for recalculation.
Definition: display.cpp:1581
virtual void render() override
Update offscreen render buffers.
Definition: display.cpp:2444
void fade_tod_mask(const std::string &old, const std::string &new_)
ToD mask smooth fade.
Definition: display.cpp:2230
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
Definition: display.cpp:3132
double turbo_speed() const
Definition: display.cpp:2155
bool reach_map_changed_
Definition: display.hpp:904
int get_location_x(const map_location &loc) const
Functions to get the on-screen positions of hexes.
Definition: display.cpp:684
static double get_zoom_factor()
Returns the current zoom factor.
Definition: display.hpp:265
void invalidate_game_status()
Function to invalidate the game status displayed on the sidebar.
Definition: display.hpp:311
void rebuild_all()
Rebuild all dynamic terrain.
Definition: display.cpp:434
virtual void layout() override
Finalize screen layout.
Definition: display.cpp:2413
virtual void highlight_hex(map_location hex)
Definition: display.cpp:1483
void update_tod(const time_of_day *tod_override=nullptr)
Applies r,g,b coloring to the map.
Definition: display.cpp:393
void process_reachmap_changes()
Definition: display.cpp:3304
void scroll_to_tile(const map_location &loc, SCROLL_TYPE scroll_type=ONSCREEN, bool check_fogged=true, bool force=true)
Scroll such that location loc is on-screen.
Definition: display.cpp:1993
map_location mouseoverHex_
Definition: display.hpp:787
bool fogged(const map_location &loc) const
Returns true if location (x,y) is covered in fog.
Definition: display.cpp:679
const gamemap & get_map() const
Definition: display.hpp:107
void invalidate_all()
Function to invalidate all tiles.
Definition: display.cpp:3125
void drawing_buffer_add(const drawing_layer layer, const map_location &loc, decltype(draw_helper::do_draw) draw_func)
Add an item to the drawing buffer.
Definition: display.cpp:1264
exclusive_unit_draw_requests_t exclusive_unit_draw_requests_
map of hexes where only one unit should be drawn, the one identified by the associated id string
Definition: display.hpp:694
std::set< map_location > invalidated_
Definition: display.hpp:776
void create_buttons()
Definition: display.cpp:852
bool invalidateGameStatus_
Definition: display.hpp:757
virtual void draw_invalidated()
Only called when there's actual redrawing to do.
Definition: display.cpp:2597
reports * reports_object_
Definition: display.hpp:759
virtual void update() override
Update animations and internal state.
Definition: display.cpp:2396
int get_location_y(const map_location &loc) const
Definition: display.cpp:689
virtual void draw_hex(const map_location &loc)
Redraws a single gamemap location.
Definition: display.cpp:2637
const std::unique_ptr< fake_unit_manager > fake_unit_man_
Definition: display.hpp:750
const display_context * dc_
Definition: display.hpp:688
static unsigned int zoom_
The current zoom, in pixels (on screen) per 72 pixels (in the graphic assets), i.e....
Definition: display.hpp:746
bool shrouded(const map_location &loc) const
Returns true if location (x,y) is covered in shroud.
Definition: display.cpp:674
bool dont_show_all_
Definition: display.hpp:732
void refresh_report(const std::string &report_name, const config *new_cfg=nullptr)
Update the given report.
Definition: display.cpp:2881
std::weak_ptr< wb::manager > wb_
Definition: display.hpp:690
virtual void select_hex(map_location hex)
Definition: display.cpp:1475
reach_map reach_map_
Definition: display.hpp:902
void set_move(double xmove, double ymove)
void set_lifetime(int lifetime, int fadeout=100)
void set_position(double xpos, double ypos)
void set_color(const color_t &color)
void set_scroll_mode(LABEL_SCROLL_MODE scroll)
void set_font_size(int font_size)
Game board class.
Definition: game_board.hpp:47
unit_map::iterator find_visible_unit(const map_location &loc, const team &current_team, bool see_all=false)
Definition: game_board.cpp:185
std::string current_team_name() const
virtual void draw_invalidated() override
Only called when there's actual redrawing to do.
void draw_movement_info(const map_location &loc)
Draws the movement info (turns available) for a given location.
void display_unit_hex(map_location hex)
Change the unit to be displayed in the sidebar.
void invalidate_unit_after_move(const map_location &src, const map_location &dst)
Same as invalidate_unit() if moving the displayed unit.
std::string attack_indicator_direction() const
Function to get attack direction suffix.
game_mode mode_
virtual void highlight_hex(map_location hex) override
Function to highlight a location.
map_location displayedUnitHex_
void invalidate_route()
void scroll_to_leader(int side, SCROLL_TYPE scroll_type=ONSCREEN, bool force=true)
Scrolls to the leader of a certain side.
void set_game_mode(const game_mode mode)
virtual void draw_hex(const map_location &loc) override
Redraws a single gamemap location.
static std::map< map_location, int > debugHighlights_
void set_attack_indicator(const map_location &src, const map_location &dst)
Set the attack direction indicator.
static int & debug_highlight(const map_location &loc)
annotate hex with number, useful for debugging or UI prototype
const std::unique_ptr< display_chat_manager > chat_man_
pathfind::marked_route route_
virtual void render() override
TLD render() override.
void set_route(const pathfind::marked_route *route)
Sets the route along which footsteps are drawn to show movement of a unit.
virtual overlay_map & get_overlays() override
Inherited from display.
std::set< map_location > units_that_can_reach_goal_
void invalidate_unit()
Function to invalidate that unit status displayed on the sidebar.
virtual void select_hex(map_location hex) override
Function to display a location as selected.
void highlight_reach(const pathfind::paths &paths_list)
Sets the paths that are currently displayed as available for the unit to move along.
void new_turn()
Update lighting settings.
void clear_attack_indicator()
virtual const time_of_day & get_time_of_day(const map_location &loc) const override
void highlight_another_reach(const pathfind::paths &paths_list, const map_location &goal=map_location::null_location())
Add more paths to highlight.
map_location attack_indicator_dst_
game_mode
Sets the linger mode for the display.
@ RUNNING
no linger overlay, show fog and shroud.
bool unhighlight_reach()
Reset highlighting of paths.
void needs_rebuild(bool b)
Sets whether the screen (map visuals) needs to be rebuilt.
overlay_map overlay_map_
bool maybe_rebuild()
Rebuilds the screen if needs_rebuild(true) was previously called, and resets the flag.
virtual void layout() override
TLD layout() override.
virtual bool has_time_area() const override
game_display(game_board &board, std::weak_ptr< wb::manager > wb, reports &reports_object, const std::string &theme_id, const config &level)
virtual void update() override
TLD update() override.
map_location attack_indicator_src_
void float_label(const map_location &loc, const std::string &text, const color_t &color)
Function to float a label above a tile.
terrain_code get_terrain(const map_location &loc) const
Looks up terrain at a particular location.
Definition: map.cpp:301
bool on_board(const map_location &loc) const
Tell if a location is on the map.
Definition: map.cpp:384
Generic locator abstracting the location of an image.
Definition: picture.hpp:59
static const int UNREACHABLE
Magic value that signifies a hex is unreachable.
Definition: movetype.hpp:174
static prefs & get()
const std::set< std::string > & report_list()
Definition: reports.cpp:1815
static bool is_synced()
const std::string & team_name() const
Definition: team.hpp:282
Wrapper class to encapsulate creation and management of an SDL_Texture.
Definition: texture.hpp:33
bool has_time_area() const
const time_of_day & get_time_of_day(int for_turn=0) const
Returns global time of day for the passed turn.
Definition: tod_manager.hpp:56
const time_of_day & get_previous_time_of_day() const
void redraw_unit(const unit &u) const
draw a unit.
Definition: drawer.cpp:164
unit_iterator end()
Definition: map.hpp:428
std::size_t count(const map_location &loc) const
Definition: map.hpp:413
unit_iterator find(std::size_t id)
Definition: map.cpp:302
unit_iterator find_leader(int side)
Definition: map.cpp:320
This class represents a single unit of a specific type.
Definition: unit.hpp:133
Drawing functions, for drawing things on the screen.
drawing_layer
@ linger_overlay
The overlay used for the linger mode.
@ reachmap
Overlay on unreachable hexes.
@ footsteps
Footsteps showing path from unit to mouse.
@ attack_indicator
Layer which holds the attack indicator.
@ mouseover_top
Top half of image following the mouse.
@ mouseover_bottom
Bottom half of image following the mouse.
@ move_info
Movement info (defense%, etc...)
@ selected_hex
Image on the selected unit.
std::size_t i
Definition: function.cpp:965
int w
static lg::log_domain log_engine("engine")
std::vector< texture > footsteps_images(const map_location &loc, const pathfind::marked_route &route_, const display_context *dc_)
Function to return 2 half-hex footsteps images for the given location.
static lg::log_domain log_display("display")
#define DBG_DP
int side() const
The side this unit belongs to.
Definition: unit.hpp:343
bool tiles_adjacent(const map_location &a, const map_location &b)
Function which tells if two locations are adjacent.
Definition: location.cpp:502
Standard logging facilities (interface).
bool is_shrouded(const display *disp, const map_location &loc)
Our definition of map labels being obscured is if the tile is obscured, or the tile below is obscured...
Definition: label.cpp:32
CURSOR_TYPE get()
Definition: cursor.cpp:216
@ WAIT
Definition: cursor.hpp:28
void blit(const texture &tex, const SDL_Rect &dst)
Draws a texture, or part of a texture, at the given location.
Definition: draw.cpp:310
const int SIZE_FLOAT_LABEL
Definition: constants.cpp:32
const color_t YELLOW_COLOR
int add_floating_label(const floating_label &flabel)
add a label floating on the screen above everything else.
const color_t BAD_COLOR
const color_t NORMAL_COLOR
@ ANCHOR_LABEL_MAP
std::string selected
std::string unreachable
std::string foot_teleport_enter
std::vector< std::string > foot_speed_prefix
std::string foot_teleport_exit
const bool & debug
Definition: game_config.cpp:92
color_t red_to_green(double val, bool for_text)
Return a color corresponding to the value val red for val=0.0 to green for val=100....
Functions to load and save images from/to disk.
@ HEXED
Standard hexagonal tile mask applied, removing portions that don't fit.
Definition: picture.hpp:166
@ TOD_COLORED
Same as HEXED, but with Time of Day color tint applied.
Definition: picture.hpp:168
texture get_texture(const image::locator &i_locator, TYPE type, bool skip_cache)
Returns an image texture suitable for hardware-accelerated rendering.
Definition: picture.cpp:920
Unit and team statistics.
::tod_manager * tod_manager
Definition: resources.cpp:29
game_board * gameboard
Definition: resources.cpp:20
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:85
std::string get_unknown_exception_type()
Utility function for finding the type of thing caught with catch(...).
Definition: general.cpp:23
Definition: display.hpp:45
std::string::const_iterator iterator
Definition: tokenizer.hpp:25
rect dst
Location on the final composed sheet.
rect src
Non-transparent portion of the surface to compose.
The basic class for representing 8-bit RGB or RGBA colour values.
Definition: color.hpp:59
Encapsulates the map of the game.
Definition: location.hpp:38
DIRECTION
Valid directions which can be moved in our hexagonal world.
Definition: location.hpp:40
bool valid() const
Definition: location.hpp:89
static const map_location & null_location()
Definition: location.hpp:81
Structure which holds a single route and marks for special events.
Definition: pathfind.hpp:142
std::vector< map_location > & steps
Definition: pathfind.hpp:187
std::vector< map_location > get_path(const const_iterator &) const
Returns the path going from the source point (included) to the destination point j (excluded).
Definition: pathfind.cpp:497
bool contains(const map_location &) const
Definition: pathfind.cpp:514
const_iterator find(const map_location &) const
Definition: pathfind.cpp:478
map_location curr
Definition: pathfind.hpp:89
Object which contains all the possible locations a unit can move to, with associated best routes to t...
Definition: pathfind.hpp:73
dest_vect destinations
Definition: pathfind.hpp:101
An abstract description of a rectangle with integer coordinates.
Definition: rect.hpp:47
Object which defines a time of day with associated bonuses, image, sounds etc.
Definition: time_of_day.hpp:57
std::string image_mask
The image that is to be laid over all images while this time of day lasts.
Definition: time_of_day.hpp:96
bool valid() const
Definition: map.hpp:273
Applies the planned unit map for the duration of the struct's life.
Definition: manager.hpp:253
#define h
#define b