The Battle for Wesnoth  1.17.23+dev
game_display.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2023
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 #include "gettext.hpp"
24 #include "wesconfig.h"
25 
26 #include "cursor.hpp"
27 #include "display_chat_manager.hpp"
28 #include "fake_unit_manager.hpp"
29 #include "fake_unit_ptr.hpp"
30 #include "floating_label.hpp"
31 #include "game_board.hpp"
32 #include "preferences/game.hpp"
33 #include "halo.hpp"
34 #include "log.hpp"
35 #include "map/map.hpp"
36 #include "map/label.hpp"
37 #include "font/standard_colors.hpp"
38 #include "reports.hpp"
39 #include "resources.hpp"
40 #include "sdl/utils.hpp"
41 #include "tod_manager.hpp"
42 #include "color.hpp"
43 #include "synced_context.hpp"
44 #include "units/unit.hpp"
45 #include "units/drawer.hpp"
46 #include "utils/general.hpp"
47 #include "whiteboard/manager.hpp"
48 #include "overlay.hpp"
49 #include "draw.hpp"
50 
51 static lg::log_domain log_display("display");
52 #define ERR_DP LOG_STREAM(err, log_display)
53 #define LOG_DP LOG_STREAM(info, log_display)
54 #define DBG_DP LOG_STREAM(debug, log_display)
55 
56 static lg::log_domain log_engine("engine");
57 #define ERR_NG LOG_STREAM(err, log_engine)
58 
59 std::map<map_location, int> game_display::debugHighlights_;
60 
61 /**
62  * Function to return 2 half-hex footsteps images for the given location.
63  * Only loc is on the current route set by set_route.
64  *
65  * This function is only used internally by game_display so I have moved it out of the header into the compilaton unit.
66  */
67 std::vector<texture> footsteps_images(const map_location& loc, const pathfind::marked_route & route_, const display_context * dc_);
68 
70  std::weak_ptr<wb::manager> wb,
71  reports& reports_object,
72  const std::string& theme_id,
73  const config& level)
74  : display(&board, wb, reports_object, theme_id, level)
75  , overlay_map_()
76  , attack_indicator_src_()
77  , attack_indicator_dst_()
78  , route_()
79  , displayedUnitHex_()
80  , first_turn_(true)
81  , in_game_(false)
82  , chat_man_(new display_chat_manager(*this))
83  , mode_(RUNNING)
84  , needs_rebuild_(false)
85 {
86 }
87 
89 {
90  try {
91  chat_man_->prune_chat_messages(true);
92  } catch(...) {
93  DBG_DP << "Caught exception in game_display destructor: " << utils::get_unknown_exception_type();
94  }
95 }
96 
98 {
99  if(!first_turn_) {
102 
103  if(old_tod.image_mask != tod.image_mask) {
104  fade_tod_mask(old_tod.image_mask, tod.image_mask);
105  }
106  }
107 
108  first_turn_ = false;
109 
110  update_tod();
111 }
112 
114 {
115  if(hex.valid() && fogged(hex)) {
116  return;
117  }
118  display::select_hex(hex);
119 
120  display_unit_hex(hex);
121 }
122 
124 {
125  wb::future_map_if future(!synced_context::is_synced()); /**< Lasts for whole method. */
126 
128  if (u) {
129  displayedUnitHex_ = hex;
130  invalidate_unit();
131  } else {
133  if (u) {
134  // mouse moved from unit hex to non-unit hex
135  if (dc_->units().count(selectedHex_)) {
137  invalidate_unit();
138  }
139  }
140  }
141 
144 }
145 
146 
148 {
149  if (!hex.valid())
150  return;
151 
152  wb::future_map_if future(!synced_context::is_synced()); /**< Lasts for whole method. */
153 
155  if (u) {
156  displayedUnitHex_ = hex;
157  invalidate_unit();
158  }
159 }
160 
162 {
163  if (src == displayedUnitHex_) {
164  displayedUnitHex_ = dst;
165  invalidate_unit();
166  }
167 }
168 
169 void game_display::scroll_to_leader(int side, SCROLL_TYPE scroll_type,bool force)
170 {
171  unit_map::const_iterator leader = dc_->units().find_leader(side);
172 
173  if(leader.valid() && leader->is_visible_to_team(dc_->get_team(viewing_side()), false)) {
174  scroll_to_tile(leader->get_location(), scroll_type, true, force);
175  }
176 }
177 
179 {
180  display::update();
181 
182  if (std::shared_ptr<wb::manager> w = wb_.lock()) {
183  w->pre_draw();
184  }
186  /**
187  * @todo FIXME: must modify changed, but best to do it at the
188  * floating_label level
189  */
190  chat_man_->prune_chat_messages();
191 }
192 
193 
195 {
196  display::render();
197 
198  if (std::shared_ptr<wb::manager> w = wb_.lock()) {
199  w->post_draw();
200  }
201 }
202 
204 {
206  if (fake_unit_man_->empty()) {
207  return;
208  }
209  unit_drawer drawer = unit_drawer(*this);
210 
211  for (const unit* temp_unit : *fake_unit_man_) {
212  const map_location& loc = temp_unit->get_location();
214  if (invalidated_.find(loc) != invalidated_.end()
215  && (request == exclusive_unit_draw_requests_.end() || request->second == temp_unit->id()))
216  drawer.redraw_unit(*temp_unit);
217  }
218 }
219 
220 namespace
221 {
222 const std::string mouseover_normal_top = "misc/hover-hex-top.png~RC(magenta>gold)";
223 const std::string mouseover_normal_bot = "misc/hover-hex-bottom.png~RC(magenta>gold)";
224 
225 const std::string mouseover_enemy_top = "misc/hover-hex-enemy-top.png~RC(magenta>red)";
226 const std::string mouseover_enemy_bot = "misc/hover-hex-enemy-bottom.png~RC(magenta>red)";
227 
228 const std::string mouseover_self_top = "misc/hover-hex-top.png~RC(magenta>green)";
229 const std::string mouseover_self_bot = "misc/hover-hex-bottom.png~RC(magenta>green)";
230 
231 const std::string mouseover_ally_top = "misc/hover-hex-top.png~RC(magenta>lightblue)";
232 const std::string mouseover_ally_bot = "misc/hover-hex-bottom.png~RC(magenta>lightblue)";
233 }
234 
236 {
237  const bool on_map = get_map().on_board(loc);
238  const bool is_shrouded = shrouded(loc);
239 
240  display::draw_hex(loc);
241 
242  if(cursor::get() == cursor::WAIT) {
243  // Interaction is disabled, so we don't need anything else
244  return;
245  }
246 
247  if(on_map && loc == mouseoverHex_ && !map_screenshot_) {
248  drawing_layer hex_top_layer = LAYER_MOUSEOVER_BOTTOM;
250  if(u != nullptr) {
251  hex_top_layer = LAYER_MOUSEOVER_TOP;
252  }
253 
254  const std::string* mo_top_path;
255  const std::string* mo_bot_path;
256 
257  if(u == nullptr) {
258  mo_top_path = &mouseover_normal_top;
259  mo_bot_path = &mouseover_normal_bot;
260  } else if(dc_->teams()[currentTeam_].is_enemy(u->side())) {
261  mo_top_path = &mouseover_enemy_top;
262  mo_bot_path = &mouseover_enemy_bot;
263  } else if(dc_->teams()[currentTeam_].side() == u->side()) {
264  mo_top_path = &mouseover_self_top;
265  mo_bot_path = &mouseover_self_bot;
266  } else {
267  mo_top_path = &mouseover_ally_top;
268  mo_bot_path = &mouseover_ally_bot;
269  }
270 
271  drawing_buffer_add(hex_top_layer, loc,
272  [tex = image::get_texture(*mo_top_path, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
273 
275  [tex = image::get_texture(*mo_bot_path, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
276  }
277 
278  // Draw reach_map information.
279  // We remove the reachability mask of the unit that we want to attack.
280  if(!is_shrouded && !reach_map_.empty() && reach_map_.find(loc) == reach_map_.end() && loc != attack_indicator_dst_) {
283  [tex = image::get_texture(unreachable, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
284  }
285 
286  if(std::shared_ptr<wb::manager> w = wb_.lock()) {
287  w->draw_hex(loc);
288 
289  if(!(w->is_active() && w->has_temp_move())) {
290  std::vector<texture> footstepImages = footsteps_images(loc, route_, dc_);
291  if(!footstepImages.empty()) {
292  drawing_buffer_add(LAYER_FOOTSTEPS, loc, [images = std::move(footstepImages)](const rect& dest) {
293  for(const texture& t : images) {
294  draw::blit(t, dest);
295  }
296  });
297  }
298  }
299  }
300 
301  // Draw the attack direction indicator
302  if(on_map && loc == attack_indicator_src_) {
304  [tex = image::get_texture("misc/attack-indicator-src-" + attack_indicator_direction() + ".png", image::HEXED)](const rect& dest)
305  { draw::blit(tex, dest); }
306  );
307  } else if(on_map && loc == attack_indicator_dst_) {
309  [tex = image::get_texture("misc/attack-indicator-dst-" + attack_indicator_direction() + ".png", image::HEXED)](const rect& dest)
310  { draw::blit(tex, dest); }
311  );
312  }
313 
314  // Linger overlay unconditionally otherwise it might give glitches
315  // so it's drawn over the shroud and fog.
316  if(mode_ != RUNNING) {
319  [tex = image::get_texture(linger, image::TOD_COLORED)](const rect& dest) { draw::blit(tex, dest); });
320  }
321 
322  if(on_map && loc == selectedHex_ && !game_config::images::selected.empty()) {
325  [tex = image::get_texture(selected, image::HEXED)](const rect& dest) { draw::blit(tex, dest); });
326  }
327 
328  // Show def% and turn to reach info
329  if(!is_shrouded && on_map) {
330  draw_movement_info(loc);
331  }
332 
333  if(game_config::debug) {
334  int debugH = debugHighlights_[loc];
335  if (debugH) {
336  std::string txt = std::to_string(debugH);
338  }
339  }
340 }
341 
343 {
345 }
346 
348 {
350 }
351 
353 {
354  display::layout();
355 
356  if ( !team_valid() )
357  return;
358 
359  refresh_report("report_clock");
360  refresh_report("report_battery");
361  refresh_report("report_countdown");
362 
364  {
365  wb::future_map future; // start planned unit map scope
366 
367  // We display the unit the mouse is over if it is over a unit,
368  // otherwise we display the unit that is selected.
369  for (const std::string &name : reports_object_->report_list()) {
370  refresh_report(name);
371  }
372  invalidateGameStatus_ = false;
373  }
374 }
375 
376 
378 {
379  if(mode != mode_) {
380  mode_ = mode;
381  invalidate_all();
382  }
383 }
384 
386 {
387  // Search if there is a mark here
389 
390  std::shared_ptr<wb::manager> wb = wb_.lock();
391 
392  // Don't use empty route or the first step (the unit will be there)
393  if(w != route_.marks.end()
394  && !route_.steps.empty() && route_.steps.front() != loc) {
395  const unit_map::const_iterator un =
396  (wb && wb->get_temp_move_unit().valid()) ?
397  wb->get_temp_move_unit() : dc_->units().find(route_.steps.front());
398  if(un != dc_->units().end()) {
399  // Display the def% of this terrain
400  int move_cost = un->movement_cost(get_map().get_terrain(loc));
401  int def = (move_cost == movetype::UNREACHABLE ?
402  0 : 100 - un->defense_modifier(get_map().get_terrain(loc)));
403  std::stringstream def_text;
404  def_text << def << "%";
405 
406  color_t color = game_config::red_to_green(def, false);
407 
408  // simple mark (no turn point) use smaller font
409  int def_font = w->second.turns > 0 ? 18 : 16;
410  draw_text_in_hex(loc, LAYER_MOVE_INFO, def_text.str(), def_font, color);
411 
413  [inv = w->second.invisible, zoc = w->second.zoc, cap = w->second.capture](const rect& dest) {
414  if(inv) {
415  draw::blit(image::get_texture(image::locator{"misc/hidden.png"}, image::HEXED), dest);
416  }
417 
418  if(zoc) {
419  draw::blit(image::get_texture(image::locator{"misc/zoc.png"}, image::HEXED), dest);
420  }
421 
422  if(cap) {
423  draw::blit(image::get_texture(image::locator{"misc/capture.png"}, image::HEXED), dest);
424  }
425  });
426 
427  //we display turn info only if different from a simple last "1"
428  if (w->second.turns > 1 || (w->second.turns == 1 && loc != route_.steps.back())) {
429  std::stringstream turns_text;
430  turns_text << w->second.turns;
431  draw_text_in_hex(loc, LAYER_MOVE_INFO, turns_text.str(), 17, font::NORMAL_COLOR, 0.5,0.8);
432  }
433 
434  // The hex is full now, so skip the "show enemy moves"
435  return;
436  }
437  }
438  // When out-of-turn, it's still interesting to check out the terrain defs of the selected unit
439  else if (selectedHex_.valid() && loc == mouseoverHex_)
440  {
441  const unit_map::const_iterator selectedUnit = resources::gameboard->find_visible_unit(selectedHex_,dc_->teams()[currentTeam_]);
442  const unit_map::const_iterator mouseoveredUnit = resources::gameboard->find_visible_unit(mouseoverHex_,dc_->teams()[currentTeam_]);
443  if(selectedUnit != dc_->units().end() && mouseoveredUnit == dc_->units().end()) {
444  // Display the def% of this terrain
445  int move_cost = selectedUnit->movement_cost(get_map().get_terrain(loc));
446  int def = (move_cost == movetype::UNREACHABLE ?
447  0 : 100 - selectedUnit->defense_modifier(get_map().get_terrain(loc)));
448  std::stringstream def_text;
449  def_text << def << "%";
450 
451  color_t color = game_config::red_to_green(def, false);
452 
453  // use small font
454  int def_font = 16;
455  draw_text_in_hex(loc, LAYER_MOVE_INFO, def_text.str(), def_font, color);
456  }
457  }
458 
459  if (!reach_map_.empty()) {
460  reach_map::iterator reach = reach_map_.find(loc);
461  if (reach != reach_map_.end() && reach->second > 1) {
462  const std::string num = std::to_string(reach->second);
463  draw_text_in_hex(loc, LAYER_MOVE_INFO, num, 16, font::YELLOW_COLOR);
464  }
465  }
466 }
467 
468 std::vector<texture> footsteps_images(const map_location& loc, const pathfind::marked_route & route_, const display_context * dc_)
469 {
470  std::vector<texture> res;
471 
472  if (route_.steps.size() < 2) {
473  return res; // no real "route"
474  }
475 
476  std::vector<map_location>::const_iterator i =
477  std::find(route_.steps.begin(),route_.steps.end(),loc);
478 
479  if( i == route_.steps.end()) {
480  return res; // not on the route
481  }
482 
483  // Check which footsteps images of game_config we will use
484  int move_cost = 1;
485  const unit_map::const_iterator u = dc_->units().find(route_.steps.front());
486  if(u != dc_->units().end()) {
487  move_cost = u->movement_cost(dc_->map().get_terrain(loc));
488  }
489  int image_number = std::min<int>(move_cost, game_config::foot_speed_prefix.size());
490  if (image_number < 1) {
491  return res; // Invalid movement cost or no images
492  }
493  const std::string foot_speed_prefix = game_config::foot_speed_prefix[image_number-1];
494 
495  texture teleport;
496 
497  // We draw 2 half-hex (with possibly different directions),
498  // but skip the first for the first step.
499  const int first_half = (i == route_.steps.begin()) ? 1 : 0;
500  // and the second for the last step
501  const int second_half = (i+1 == route_.steps.end()) ? 0 : 1;
502 
503  for (int h = first_half; h <= second_half; ++h) {
504  const std::string sense( h==0 ? "-in" : "-out" );
505 
506  if (!tiles_adjacent(*(i+(h-1)), *(i+h))) {
507  std::string teleport_image =
509  teleport = image::get_texture(teleport_image, image::HEXED);
510  continue;
511  }
512 
513  // In function of the half, use the incoming or outgoing direction
514  map_location::DIRECTION dir = (i+(h-1))->get_relative_dir(*(i+h));
515 
516  std::string rotate;
517  if (dir > map_location::SOUTH_EAST) {
518  // No image, take the opposite direction and do a 180 rotation
519  dir = i->get_opposite_dir(dir);
520  rotate = "~FL(horiz)~FL(vert)";
521  }
522 
523  const std::string image = foot_speed_prefix
524  + sense + "-" + i->write_direction(dir)
525  + ".png" + rotate;
526 
527  res.push_back(image::get_texture(image, image::HEXED));
528  }
529 
530  // we draw teleport image (if any) in last
531  if (teleport != nullptr) res.push_back(teleport);
532 
533  return res;
534 }
535 
536 
537 
539 {
541  highlight_another_reach(paths_list);
542 }
543 
545  const map_location& goal)
546 {
547  // Fold endpoints of routes into reachability map.
548  for (const pathfind::paths::step &dest : paths_list.destinations) {
549  reach_map_[dest.curr]++;
550  }
551  reach_map_changed_ = true;
552 
553  if(goal != map_location::null_location() && paths_list.destinations.contains(goal)) {
554  const auto& path_to_goal = paths_list.destinations.get_path(paths_list.destinations.find(goal));
555  const map_location enemy_unit_location = path_to_goal[0];
556  units_that_can_reach_goal_.insert(enemy_unit_location);
557  }
558 }
559 
561 {
563  if(!reach_map_.empty()) {
564  reach_map_.clear();
565  reach_map_changed_ = true;
566  return true;
567  } else {
568  return false;
569  }
570 }
571 
573 {
574  for(std::vector<map_location>::const_iterator i = route_.steps.begin();
575  i != route_.steps.end(); ++i) {
576  invalidate(*i);
577  }
578 }
579 
581 {
583 
584  if(route != nullptr) {
585  route_ = *route;
586  } else {
587  route_.steps.clear();
588  route_.marks.clear();
589  }
590 
592 }
593 
594 void game_display::float_label(const map_location& loc, const std::string& text, const color_t& color)
595 {
596  if(preferences::show_floating_labels() == false || fogged(loc)) {
597  return;
598  }
599 
600  font::floating_label flabel(text);
602  flabel.set_color(color);
603  flabel.set_position(get_location_x(loc)+zoom_/2, get_location_y(loc));
604  flabel.set_move(0, -0.1 * turbo_speed() * get_zoom_factor());
605  flabel.set_lifetime(1000/turbo_speed());
607 
608  font::add_floating_label(flabel);
609 }
610 
612 {
613  assert(game_config::debug);
614  return debugHighlights_[loc];
615 }
616 
618 {
619  if (attack_indicator_src_ != src || attack_indicator_dst_ != dst) {
622 
623  attack_indicator_src_ = src;
624  attack_indicator_dst_ = dst;
625 
628  }
629 }
630 
632 {
634 }
635 
637 {
638  if (team_valid())
639  {
640  return dc_->teams()[currentTeam_].team_name();
641  }
642  return std::string();
643 }
644 
646 {
647  in_game_ = true;
648  create_buttons();
649  invalidate_all();
650 }
651 
653  if (b) {
654  needs_rebuild_ = true;
655  }
656 }
657 
659  if (needs_rebuild_) {
660  needs_rebuild_ = false;
662  invalidate_all();
663  rebuild_all();
664  return true;
665  }
666  return false;
667 }
668 
670 {
671  return overlay_map_;
672 }
const std::vector< map_location > & route_
Definition: move.cpp:295
double t
Definition: astarsearch.cpp:65
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:161
Abstract class for exposing game data that doesn't depend on the GUI, however which for historical re...
const team & get_team(int side) const
This getter takes a 1-based side number, not a 0-based team number.
virtual const gamemap & map() const =0
virtual const std::vector< team > & teams() 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:87
bool map_screenshot_
Used to indicate to drawing functions that we are doing a map screenshot.
Definition: display.hpp:932
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:1477
int viewing_side() const
The 1-based equivalent of the 0-based viewing_team() function.
Definition: display.hpp:130
std::map< map_location, std::vector< overlay > > overlay_map
Definition: display.hpp:952
map_location selectedHex_
Definition: display.hpp:780
std::size_t viewing_team() const
The viewing team is the team currently viewing the game.
Definition: display.hpp:122
void recalculate_minimap()
Schedule the minimap for recalculation.
Definition: display.cpp:1653
virtual void render() override
Update offscreen render buffers.
Definition: display.cpp:2481
void fade_tod_mask(const std::string &old, const std::string &new_)
ToD mask smooth fade.
Definition: display.cpp:2267
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
Definition: display.cpp:3147
drawing_layer
The layers to render something on.
Definition: display.hpp:808
@ LAYER_MOUSEOVER_BOTTOM
Bottom half of image following the mouse.
Definition: display.hpp:836
@ LAYER_ATTACK_INDICATOR
Layer which holds the attack indicator.
Definition: display.hpp:841
@ LAYER_MOVE_INFO
Movement info (defense%, etc...).
Definition: display.hpp:846
@ LAYER_FOOTSTEPS
Footsteps showing path from unit to mouse.
Definition: display.hpp:815
@ LAYER_LINGER_OVERLAY
The overlay used for the linger mode.
Definition: display.hpp:847
@ LAYER_SELECTED_HEX
Image on the selected unit.
Definition: display.hpp:840
@ LAYER_REACHMAP
"black stripes" on unreachable hexes.
Definition: display.hpp:835
@ LAYER_MOUSEOVER_TOP
Top half of image following the mouse.
Definition: display.hpp:816
double turbo_speed() const
Definition: display.cpp:2238
bool reach_map_changed_
Definition: display.hpp:949
int get_location_x(const map_location &loc) const
Functions to get the on-screen positions of hexes.
Definition: display.cpp:712
static double get_zoom_factor()
Returns the current zoom factor.
Definition: display.hpp:267
void invalidate_game_status()
Function to invalidate the game status displayed on the sidebar.
Definition: display.hpp:313
void rebuild_all()
Rebuild all dynamic terrain.
Definition: display.cpp:457
virtual void layout() override
Finalize screen layout.
Definition: display.cpp:2450
virtual void highlight_hex(map_location hex)
Definition: display.cpp:1555
void update_tod(const time_of_day *tod_override=nullptr)
Applies r,g,b coloring to the map.
Definition: display.cpp:410
void process_reachmap_changes()
Definition: display.cpp:3319
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:2075
map_location mouseoverHex_
Definition: display.hpp:781
bool fogged(const map_location &loc) const
Returns true if location (x,y) is covered in fog.
Definition: display.cpp:707
const gamemap & get_map() const
Definition: display.hpp:105
void invalidate_all()
Function to invalidate all tiles.
Definition: display.cpp:3140
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:1288
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:688
bool team_valid() const
Definition: display.cpp:697
std::set< map_location > invalidated_
Definition: display.hpp:770
void create_buttons()
Definition: display.cpp:880
bool invalidateGameStatus_
Definition: display.hpp:751
virtual void draw_invalidated()
Only called when there's actual redrawing to do.
Definition: display.cpp:2640
reports * reports_object_
Definition: display.hpp:753
virtual void update() override
Update animations and internal state.
Definition: display.cpp:2433
int get_location_y(const map_location &loc) const
Definition: display.cpp:717
virtual void draw_hex(const map_location &loc)
Redraws a single gamemap location.
Definition: display.cpp:2681
std::size_t currentTeam_
Definition: display.hpp:725
const std::unique_ptr< fake_unit_manager > fake_unit_man_
Definition: display.hpp:744
const display_context * dc_
Definition: display.hpp:682
static unsigned int zoom_
The current zoom, in pixels (on screen) per 72 pixels (in the graphic assets), i.e....
Definition: display.hpp:740
bool shrouded(const map_location &loc) const
Returns true if location (x,y) is covered in shroud.
Definition: display.cpp:702
bool dont_show_all_
Definition: display.hpp:726
void refresh_report(const std::string &report_name, const config *new_cfg=nullptr)
Update the given report.
Definition: display.cpp:2896
std::weak_ptr< wb::manager > wb_
Definition: display.hpp:684
virtual void select_hex(map_location hex)
Definition: display.cpp:1547
reach_map reach_map_
Definition: display.hpp:947
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:53
unit_map::iterator find_visible_unit(const map_location &loc, const team &current_team, bool see_all=false)
Definition: game_board.cpp:184
unit * get_visible_unit(const map_location &loc, const team &current_team, bool see_all=false)
Definition: game_board.cpp:212
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:302
bool on_board(const map_location &loc) const
Tell if a location is on the map.
Definition: map.cpp:385
Generic locator abstracting the location of an image.
Definition: picture.hpp:64
static const int UNREACHABLE
Magic value that signifies a hex is unreachable.
Definition: movetype.hpp:176
const std::set< std::string > & report_list()
Definition: reports.cpp:1818
static bool is_synced()
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:167
unit_iterator end()
Definition: map.hpp:429
std::size_t count(const map_location &loc) const
Definition: map.hpp:414
unit_iterator find(std::size_t id)
Definition: map.cpp:301
unit_iterator find_leader(int side)
Definition: map.cpp:319
This class represents a single unit of a specific type.
Definition: unit.hpp:135
Drawing functions, for drawing things on the screen.
std::size_t i
Definition: function.cpp:968
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:345
bool tiles_adjacent(const map_location &a, const map_location &b)
Function which tells if two locations are adjacent.
Definition: location.cpp:503
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:29
void blit(const texture &tex, const SDL_Rect &dst)
Draws a texture, or part of a texture, at the given location.
Definition: draw.cpp:311
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:91
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:235
@ TOD_COLORED
Same as HEXED, but with Time of Day color tint applied.
Definition: picture.hpp:237
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:985
bool show_floating_labels()
Definition: game.cpp:823
Unit and team statistics.
::tod_manager * tod_manager
Definition: resources.cpp:30
game_board * gameboard
Definition: resources.cpp:21
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:87
std::string get_unknown_exception_type()
Utility function for finding the type of thing caught with catch(...).
Definition: general.cpp:23
Definition: display.hpp:49
std::string::const_iterator iterator
Definition: tokenizer.hpp:25
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:274
Applies the planned unit map for the duration of the struct's life.
Definition: manager.hpp:253
Some defines: VERSION, PACKAGE, MIN_SAVEGAME_VERSION.
#define h
#define b