55 #include <boost/algorithm/string/trim.hpp>
72 #define ERR_DP LOG_STREAM(err, log_display)
73 #define WRN_DP LOG_STREAM(warn, log_display)
74 #define LOG_DP LOG_STREAM(info, log_display)
75 #define DBG_DP LOG_STREAM(debug, log_display)
78 #define zoom_levels (game_config::zoom_levels)
79 #define final_zoom_index (static_cast<int>(zoom_levels.size()) - 1)
80 #define DefaultZoom (game_config::tile_size)
81 #define SmallZoom (DefaultZoom / 2)
82 #define MinZoom (zoom_levels.front())
83 #define MaxZoom (zoom_levels.back())
101 float diff = *iter - *(iter - 1);
102 float lower = (zoom_level - *(iter - 1)) / diff;
103 float upper = (*iter - zoom_level) / diff;
114 void display::add_overlay(
const map_location& loc,
const std::string& img,
const std::string&
halo,
const std::string& team_name,
const std::string& item_id,
bool visible_under_fog,
float submerge,
float z_order)
123 auto it = std::find_if(overlays.begin(), overlays.end(), [z_order](
const overlay& ov) { return ov.z_order > z_order; });
124 overlays.emplace(it, img,
halo, halo_handle, team_name, item_id, visible_under_fog, submerge, z_order);
137 overlays.begin(), overlays.end(),
138 [&toDelete](
const overlay& ov) { return ov.image == toDelete || ov.halo == toDelete || ov.id == toDelete; }
145 std::weak_ptr<wb::manager>
wb,
147 const std::string& theme_id,
152 , exclusive_unit_draw_requests_()
154 , dont_show_all_(false)
157 , view_locked_(false)
161 , builder_(new
terrain_builder(
level, (dc_ ? &dc_->map() : nullptr), theme_.border().tile_image, theme_.border().show_border))
162 , minimap_renderer_(nullptr)
164 , redraw_background_(false)
165 , invalidateAll_(true)
166 , diagnostic_label_(0)
167 , invalidateGameStatus_(true)
169 , reports_object_(&reports_object)
170 , scroll_event_(
"scrolled")
181 , tod_hex_mask1(nullptr)
182 , tod_hex_mask2(nullptr)
189 , animate_water_(true)
193 , map_screenshot_(false)
196 , reach_map_changed_(true)
198 , invalidated_hexes_(0)
200 , redraw_observers_()
219 if(tile_size < MinZoom || tile_size >
MaxZoom)
265 std::vector<std::string> side_colors;
266 side_colors.reserve(
dc_->
teams().size());
269 std::string side_color =
t.color();
270 side_colors.push_back(side_color);
282 assert(
dc_ !=
nullptr);
283 assert(n < dc_->teams().
size());
288 std::string new_rgb = side_color;
294 LOG_DP <<
"Adding flag for team " <<
n <<
" from animation " <<
flag;
303 std::string str =
item;
306 if(sub_items.size() > 1) {
307 str = sub_items.front();
309 time = std::max<int>(1, std::stoi(sub_items.back()));
310 }
catch(
const std::invalid_argument&) {
311 ERR_DP <<
"Invalid time value found when constructing flag for side " <<
n <<
": " << sub_items.back();
315 std::stringstream temp;
316 temp << str <<
"~RC(" << old_rgb <<
">"<< new_rgb <<
")";
323 auto time =
f.get_end_time();
329 ERR_DP <<
"missing flag for team" <<
n;
335 if(!
get_map().is_village(loc)) {
343 flag.update_last_draw_time();
345 flag.get_current_frame() :
flag.get_first_frame();
355 assert(teamindex < dc_->teams().
size());
365 if(std::shared_ptr<wb::manager>
w =
wb_.lock()) {
366 w->on_viewer_change(teamindex);
372 assert(teamindex < dc_->teams().
size());
432 std::ostringstream
s;
438 images.push_back(
s.str());
443 images.emplace_back();
449 return variants[std::abs(loc.
x + loc.
y) % variants.size()];
499 rect max_area{0, 0, 0, 0};
525 if(max_area.w < res.w) {
527 res.x += (res.w - max_area.w) / 2;
531 if(max_area.h < res.h) {
533 res.y += (res.h - max_area.h) / 2;
553 return (x < area.x || x > area.x + area.w - x_thresh || y < area.y || y > area.y + area.h - y_thresh);
579 const int offset = y < 0 ? 1 : 0;
585 const int tesselation_x_size =
hex_width() * 2;
586 const int tesselation_y_size =
s;
587 const int x_base = x / tesselation_x_size * 2;
588 const int x_mod = x % tesselation_x_size;
589 const int y_base = y / tesselation_y_size;
590 const int y_mod = y % tesselation_y_size;
595 if (y_mod < tesselation_y_size / 2) {
596 if ((x_mod * 2 + y_mod) < (
s / 2)) {
599 }
else if ((x_mod * 2 - y_mod) < (
s * 3 / 2)) {
608 if ((x_mod * 2 - (y_mod -
s / 2)) < 0) {
611 }
else if ((x_mod * 2 + (y_mod -
s / 2)) <
s * 2) {
620 return map_location(x_base + x_modifier - offset, y_base + y_modifier - offset);
649 if(r.w <= 0 || r.h <= 0) {
662 int x =
xpos_ - map_rect.x + r.x;
663 int y =
ypos_ - map_rect.y + r.y;
673 res.
left =
static_cast<int>(std::floor(-border + x / tile_width - 0.3333333));
676 res.
right =
static_cast<int>(std::floor(-border + (x + r.w - 1) / tile_width));
680 res.
top[0] =
static_cast<int>(std::floor(-border + y /
tile_size));
681 res.
top[1] =
static_cast<int>(std::floor(-border + y /
tile_size - 0.5));
682 res.
bottom[0] =
static_cast<int>(std::floor(-border + (y + r.h - 1) /
tile_size));
683 res.
bottom[1] =
static_cast<int>(std::floor(-border + (y + r.h - 1) /
tile_size - 0.5));
759 if (!map_screenshot) {
760 LOG_DP <<
"taking ordinary screenshot";
765 ERR_DP <<
"No map loaded, cannot create a map screenshot.";
770 int old_xpos =
xpos_;
771 int old_ypos =
ypos_;
777 if (area.w > 1 << 16 || area.h > 1 << 16) {
778 WRN_DP <<
"Excessively large map screenshot area";
780 LOG_DP <<
"creating " << area.w <<
" by " << area.h
781 <<
" texture for map screenshot";
782 texture output_texture(area.w, area.h, SDL_TEXTUREACCESS_TARGET);
788 DBG_DP <<
"invalidating region for map screenshot";
791 DBG_DP <<
"drawing map screenshot";
801 LOG_DP <<
"reading pixels for map screenshot";
827 DBG_DP <<
"positioning menu buttons...";
831 b->set_location(loc);
832 b->set_measurements(0,0);
833 b->set_label(menu.title());
834 b->set_image(menu.image());
838 DBG_DP <<
"positioning action buttons...";
842 b->set_location(loc);
843 b->set_measurements(0,0);
844 b->set_label(action.title());
845 b->set_image(action.image());
854 if(
type ==
"checkbox") {
856 }
else if(
type ==
"image") {
858 }
else if(
type ==
"radiobox") {
860 }
else if(
type ==
"turbo") {
867 const std::string& get_direction(std::size_t
n)
869 using namespace std::literals::string_literals;
870 static const std::array dirs{
"-n"s,
"-ne"s,
"-se"s,
"-s"s,
"-sw"s,
"-nw"s};
871 return dirs[
n >= dirs.size() ? 0 :
n];
882 std::vector<std::shared_ptr<gui::button>> menu_work;
883 std::vector<std::shared_ptr<gui::button>> action_work;
885 DBG_DP <<
"creating menu buttons...";
887 if(!menu.is_button()) {
894 DBG_DP <<
"drawing button " << menu.get_id();
895 b->set_id(menu.get_id());
896 if(!menu.tooltip().empty()) {
897 b->set_tooltip_string(menu.tooltip());
901 b->enable(b_prev->enabled());
904 menu_work.push_back(std::move(
b));
907 DBG_DP <<
"creating action buttons...";
909 auto b = std::make_shared<gui::button>(action.title(), string_to_button_type(action.type()),
912 DBG_DP <<
"drawing button " << action.get_id();
913 b->set_id(action.get_id());
914 if(!action.tooltip(0).empty()) {
915 b->set_tooltip_string(action.tooltip(0));
919 b->enable(b_prev->enabled());
921 b->set_check(b_prev->checked());
925 action_work.push_back(std::move(
b));
937 DBG_DP <<
"buttons created";
984 std::vector<std::string>
names;
987 enum visibility { FOG = 0, SHROUD = 1, CLEAR = 2 };
988 std::array<visibility, 6> tiles;
992 for(
int i = 0;
i < 6; ++
i) {
1002 for(
int v = FOG; v != CLEAR; ++v) {
1006 if(tiles[
start] != v) {
1014 const std::string name = *image_prefix[v] +
"-all.png";
1016 names.push_back(name);
1026 for(
int i = (
start + 1) % 6, cap1 = 0;
i !=
start && cap1 != 6; ++cap1) {
1028 std::ostringstream stream;
1030 stream << *image_prefix[v];
1032 for(
int cap2 = 0; v == tiles[
i] && cap2 != 6;
i = (
i + 1) % 6, ++cap2) {
1033 stream << get_direction(
i);
1043 name = stream.str();
1048 names.push_back(name +
".png");
1057 std::vector<texture> res;
1059 for(
const std::string& name :
names) {
1061 res.push_back(std::move(tex));
1077 std::array<
const time_of_day*, adjs.size()> atods;
1079 for(std::size_t
d = 0;
d < adjs.size(); ++
d) {
1083 for(
int d = 0;
d < 6; ++
d) {
1115 for(
int d = 0;
d < 6; ++
d) {
1147 for(
int d = 0;
d < 6; ++
d) {
1194 for(
const auto& terrain : *terrains) {
1202 const bool off_map = (
image.get_filename() == off_map_name
1203 ||
image.get_modifications().find(
"NO_TOD_SHIFT()") != std::string::npos);
1207 }
else if(lt.empty()) {
1222 constexpr std::array layer_groups {
1237 BITS_FOR_LAYER_GROUP = 4,
1243 BITS_FOR_X_PARITY = 1,
1249 BITS_FOR_X_OVER_2 = 9,
1251 SHIFT_LAYER = BITS_FOR_X_OVER_2,
1253 SHIFT_X_PARITY = BITS_FOR_LAYER + SHIFT_LAYER,
1255 SHIFT_Y = BITS_FOR_X_PARITY + SHIFT_X_PARITY,
1257 SHIFT_LAYER_GROUP = BITS_FOR_Y + SHIFT_Y
1263 uint32_t group_i = layer_groups.size() - 1;
1266 while(layer < layer_groups[group_i]) {
1274 const uint32_t x_parity =
static_cast<uint32_t
>(loc.
x) & 1;
1277 static_assert(SHIFT_LAYER_GROUP + BITS_FOR_LAYER_GROUP ==
sizeof(key) * 8,
"Bit field too small");
1279 key = (group_i << SHIFT_LAYER_GROUP) | (static_cast<uint32_t>(loc.
y + MAX_BORDER) << SHIFT_Y);
1280 key |= (x_parity << SHIFT_X_PARITY);
1281 key |= (
static_cast<uint32_t
>(layer) << SHIFT_LAYER) |
static_cast<uint32_t
>(loc.
x + MAX_BORDER) / 2;
1298 drawing_buffer_.emplace_back(generate_hex_key(layer, loc), draw_func, dest);
1300 draw_helper temp{generate_hex_key(layer, loc), draw_func, dest};
1307 DBG_DP <<
"committing drawing buffer"
1328 std::invoke(helper.do_draw, helper.dest);
1337 return frametime != 0u ? 1000u / frametime : 999u;
1343 const int sample_freq = 10;
1362 *fps_log << std::get<0>(fps) <<
"," << std::get<1>(fps) <<
"," << std::get<2>(fps) <<
"\n";
1371 std::ostringstream stream;
1372 stream <<
"<tt> min/avg/max/act</tt>\n";
1373 stream <<
"<tt>FPS: " << std::setfill(
' ') << std::setw(3) << min_fps <<
'/'<< std::setw(3) << avg_fps <<
'/' << std::setw(3) << max_fps <<
'/' << std::setw(3) <<
fps_actual_ <<
"</tt>\n";
1374 stream <<
"<tt>Time: " << std::setfill(
' ') << std::setw(3) << *minmax_it.first <<
'/' << std::setw(3) << render_avg <<
'/' << std::setw(3) << *minmax_it.second <<
" ms</tt>\n";
1405 if (panel.
image().empty()) {
1415 DBG_DP <<
"drawing panel " << panel.
get_id() <<
' ' << loc;
1420 <<
" texture: " << panel.
image();
1435 const std::string& text =
label.text();
1437 const std::string& icon =
label.icon();
1439 DBG_DP <<
"drawing label " <<
label.get_id() <<
' ' << loc;
1441 if(icon.empty() ==
false) {
1444 if(text.empty() ==
false) {
1447 }
else if(text.empty() ==
false) {
1449 text_color, text, loc.x, loc.y
1478 const std::string& text,
1479 std::size_t font_size,
1484 if (text.empty())
return;
1490 renderer.set_maximum_height(-1,
false);
1491 renderer.set_foreground_color(color);
1496 dest.x - (res.w() / 2) + static_cast<int>(x_in_hex * dest.w),
1497 dest.y - (res.h() / 2) + static_cast<int>(y_in_hex * dest.h),
1510 image_path =
"misc/blank-hex.png~BLIT(" + image_path;
1524 if (submersion_amount > 0.0) {
1525 int submersion_line = image_height * (1.0 - submersion_amount);
1526 const std::string sl_string = std::to_string(submersion_line);
1527 image_path +=
"~ADJUST_ALPHA(if(y>";
1528 image_path += sl_string;
1529 image_path +=
",clamp((0.3-(y-";
1530 image_path += sl_string;
1531 image_path +=
")*0.015),0,1)*alpha,alpha))";
1540 image_path +=
",0,";
1541 image_path += std::to_string(shift);
1585 if(time_between_draws < 0) {
1591 using std::chrono::duration_cast;
1592 using std::chrono::seconds;
1593 using std::chrono::steady_clock;
1594 const seconds current_second = duration_cast<seconds>(steady_clock::now().time_since_epoch());
1607 if((*i)->pressed()) {
1623 if((*i)->pressed()) {
1638 if(
options.discard_previous) {
1687 ERR_DP <<
"trying to draw null minimap";
1712 double shift_x = -border *
hex_width() - (map_out_rect.w - map_rect.w) / 2;
1713 double shift_y = -(border + 0.25) *
hex_size() - (map_out_rect.h - map_rect.h) / 2;
1715 int view_x =
static_cast<int>((
xpos_ + shift_x) * xscaling);
1716 int view_y =
static_cast<int>((
ypos_ + shift_y) * yscaling);
1717 int view_w =
static_cast<int>(map_out_rect.w * xscaling);
1718 int view_h =
static_cast<int>(map_out_rect.h * yscaling);
1720 SDL_Rect outline_rect {
1737 for(
const auto& u :
dc_->
units()) {
1738 if (
fogged(u.get_location()) ||
1740 u.invisible(u.get_location())) ||
1745 int side = u.side();
1752 }
else if(
currentTeam_ + 1 ==
static_cast<unsigned>(side)) {
1760 double u_x = u.get_location().x * xscaling;
1761 double u_y = (u.get_location().y + (
is_odd(u.get_location().x) ? 1 : -1)/4.0) * yscaling;
1763 double u_w = 4.0 / 3.0 * xscaling;
1764 double u_h = yscaling;
1769 , int(std::round(u_w))
1770 , int(std::round(u_h))
1784 if(xmove == 0 && ymove == 0) {
1788 int new_x =
xpos_ + xmove;
1789 int new_y =
ypos_ + ymove;
1798 const int diff_x =
xpos_ - new_x;
1799 const int diff_y =
ypos_ - new_y;
1852 r.y = r.y + r.h + diff_y;
1855 r.h = std::abs(diff_y);
1863 r.x = r.x + r.w + diff_x;
1866 r.w = std::abs(diff_x);
1901 LOG_DP <<
"new_zoom = " << new_zoom;
1903 if(new_zoom ==
zoom_) {
1907 if(validate_value_and_set_index) {
1912 if((new_zoom / 4) * 4 != new_zoom) {
1913 WRN_DP <<
"set_zoom forcing zoom " << new_zoom
1914 <<
" which is not a multiple of 4."
1915 <<
" This will likely cause graphical glitches.";
1922 double zoom_factor =
static_cast<double>(new_zoom) /
static_cast<double>(
zoom_);
1936 xpos_ = std::round(((
xpos_ + area.w / 2) * zoom_factor) - (area.w / 2));
1937 ypos_ = std::round(((
ypos_ + area.h / 2) * zoom_factor) - (area.h / 2));
1981 return x + hs >= area.x - hw && x < area.x + area.w + hw &&
1982 y + hs >= area.y - hs && y < area.y + area.h + hs;
1992 const int xmove_expected = screenxpos - (area.x + area.w/2);
1993 const int ymove_expected = screenypos - (area.y + area.h/2);
1995 int xpos =
xpos_ + xmove_expected;
1996 int ypos =
ypos_ + ymove_expected;
1998 int xmove = xpos -
xpos_;
1999 int ymove = ypos -
ypos_;
2002 scroll(xmove,ymove,
true);
2013 const double dist_total = std::hypot(xmove, ymove);
2014 double dist_moved = 0.0;
2016 int t_prev = SDL_GetTicks();
2018 double velocity = 0.0;
2019 while (dist_moved < dist_total) {
2022 int t = SDL_GetTicks();
2023 double dt = (
t - t_prev) / 1000.0;
2035 double accel = velocity_max / accel_time;
2036 double decel = velocity_max / decel_time;
2039 double stop_time = velocity / decel;
2040 double dist_stop = dist_moved + velocity*stop_time - 0.5*decel*stop_time*stop_time;
2041 if (dist_stop > dist_total || velocity > velocity_max) {
2042 velocity -= decel * dt;
2043 if (velocity < 1.0) velocity = 1.0;
2045 velocity += accel * dt;
2046 if (velocity > velocity_max) velocity = velocity_max;
2049 dist_moved += velocity * dt;
2050 if (dist_moved > dist_total) dist_moved = dist_total;
2052 int x_new = std::round(xmove * dist_moved / dist_total);
2053 int y_new = std::round(ymove * dist_moved / dist_total);
2055 int dx = x_new - x_old;
2056 int dy = y_new - y_old;
2069 if(
get_map().on_board(loc) ==
false) {
2070 ERR_DP <<
"Tile at " << loc <<
" isn't on the map, can't scroll to the tile.";
2074 std::vector<map_location> locs;
2075 locs.push_back(loc);
2081 double add_spacing,
bool force)
2083 std::vector<map_location> locs;
2084 locs.push_back(loc1);
2085 locs.push_back(loc2);
2086 scroll_to_tiles(locs, scroll_type, check_fogged,
false, add_spacing,force);
2090 const std::vector<map_location>::const_iterator &
end,
2092 bool only_if_possible,
double add_spacing,
bool force)
2101 for(std::vector<map_location>::const_iterator itor =
begin; itor !=
end ; ++itor) {
2102 if(
get_map().on_board(*itor) ==
false)
continue;
2103 if(check_fogged &&
fogged(*itor))
continue;
2115 int minx_new = std::min<int>(minx,x);
2116 int miny_new = std::min<int>(miny,y);
2117 int maxx_new = std::max<int>(maxx,x);
2118 int maxy_new = std::max<int>(maxy,y);
2124 if (only_if_possible)
return;
2138 int spacing = std::round(add_spacing *
hex_size());
2152 locs_bbox.w = maxx - minx +
hex_size();
2153 locs_bbox.h = maxy - miny +
hex_size();
2156 int target_x = locs_bbox.x + locs_bbox.w/2;
2157 int target_y = locs_bbox.y + locs_bbox.h/2;
2162 int map_center_x = r.x + r.w/2;
2163 int map_center_y = r.y + r.h/2;
2169 double inside_frac = 0.5;
2170 w =
static_cast<int>(
w * inside_frac);
2171 h =
static_cast<int>(
h * inside_frac);
2181 r.x = target_x -
w/2;
2182 r.y = target_y -
h/2;
2190 if (map_center_x < r.x) {
2192 target_y = std::clamp(map_center_y, r.y, r.y + r.h - 1);
2193 }
else if (map_center_x > r.x+r.w-1) {
2194 target_x = r.x + r.w - 1;
2195 target_y = std::clamp(map_center_y, r.y, r.y + r.h - 1);
2196 }
else if (map_center_y < r.y) {
2198 target_x = std::clamp(map_center_x, r.x, r.x + r.w - 1);
2199 }
else if (map_center_y > r.y+r.h-1) {
2200 target_y = r.y + r.h - 1;
2201 target_x = std::clamp(map_center_x, r.x, r.x + r.w - 1);
2203 ERR_DP <<
"Bug in the scrolling code? Looks like we would not need to scroll after all...";
2226 xpos = std::clamp(xpos, 0, xend -
map_area().
w);
2227 ypos = std::clamp(ypos, 0, yend -
map_area().
h);
2233 if(
keys_[SDLK_LSHIFT] ||
keys_[SDLK_RSHIFT]) {
2260 const std::string& old_mask,
2261 const std::string& new_mask)
2268 int start = SDL_GetTicks();
2269 for(
int now =
start; now <
start + duration; now = SDL_GetTicks()) {
2270 float prop_f = float(now -
start) / float(duration);
2284 uint32_t
start = SDL_GetTicks();
2289 if(fade_start.a == 0) {
2290 fade_start.r = fade_end.r;
2291 fade_start.g = fade_end.g;
2292 fade_start.b = fade_end.b;
2296 if(fade_end.a == 0) {
2297 fade_end.r = fade_start.r;
2298 fade_end.g = fade_start.g;
2299 fade_end.b = fade_start.b;
2303 for(uint32_t now =
start; now <
start + duration; now = SDL_GetTicks()) {
2304 float prop_f = float(now -
start) / float(duration);
2325 DBG_DP <<
"redrawing everything";
2348 if(command_executor !=
nullptr) {
2392 DBG_DP <<
"display::draw denied";
2403 DBG_DP <<
"display::draw redraw background";
2456 DBG_DP <<
"draw() with invalidateAll";
2481 DBG_DP <<
"render prevented";
2495 ERR_DP <<
"error creating minimap";
2504 DBG_DP <<
"draw prevented";
2539 DBG_DP <<
"display::expose " << region;
2569 bool raw_size_changed =
size.x != oarea.w ||
size.y != oarea.h;
2570 bool draw_size_changed = dsize.x != darea.w || dsize.y != darea.h;
2571 if (!raw_size_changed && !draw_size_changed) {
2576 if(raw_size_changed) {
2577 LOG_DP <<
"regenerating render buffers as " << oarea;
2578 front_ =
texture(oarea.w, oarea.h, SDL_TEXTUREACCESS_TARGET);
2579 back_ =
texture(oarea.w, oarea.h, SDL_TEXTUREACCESS_TARGET);
2581 if(raw_size_changed || draw_size_changed) {
2582 LOG_DP <<
"updating render buffer draw size to " << darea;
2588 for(
int i = 0;
i < 2; ++
i) {
2605 for(
int i = 0;
i < 2; ++
i) {
2636 DBG_DP <<
"drawing " <<
invalidated_.size() <<
" invalidated hexes with clip " << clip_rect;
2639 std::optional<unit_drawer> drawer{};
2641 drawer.emplace(*
this);
2649 if(!hex_rect.
overlaps(clip_rect)) {
2661 drawer->redraw_unit(*u_it);
2676 int num_images_fg = 0;
2677 int num_images_bg = 0;
2721 std::vector<overlay>& overlays = it->second;
2722 if(overlays.size() != 0) {
2726 for(
const overlay& ov : overlays) {
2727 bool item_visible_for_team =
true;
2731 const std::vector<std::string>& current_team_names =
utils::split(current_team_name);
2732 const std::vector<std::string>& team_names =
utils::split(ov.team_name);
2734 item_visible_for_team = std::find_first_of(team_names.begin(), team_names.end(),
2735 current_team_names.begin(), current_team_names.end()) != team_names.end();
2738 if(item_visible_for_team && !(
fogged(loc) && !ov.visible_in_fog)) {
2740 std::string ipf = ov.image;
2744 double sub = submerge * ov.submerge;
2747 int shift = isize.y * (sub - submerge);
2751 const texture tex = ov.image.find(
"~NO_TOD_SHIFT()") == std::string::npos
2769 const std::string& tod_hex_mask = tod.
image_mask;
2778 }
else if(!tod_hex_mask.empty()) {
2784 arrows_map_t::const_iterator arrows_in_hex =
arrows_map_.find(loc);
2786 for (
arrow*
const a : arrows_in_hex->second) {
2831 std::ostringstream ss;
2841 ss << (num_images_bg + num_images_fg) <<
'\n';
2844 std::string
output = ss.str();
2854 renderer.set_alignment(PANGO_ALIGN_CENTER);
2856 renderer.set_maximum_height(-1,
false);
2860 const rect text_dest {
2861 (dest.x + dest.w / 2) - (tex.w() / 2),
2862 (dest.y + dest.h / 2) - (tex.h() / 2),
2868 const rect bg_dest {
2907 if ( new_cfg ==
nullptr )
2908 new_cfg = &generated_cfg;
2915 if (loc == new_loc && report == *new_cfg) {
2919 DBG_DP <<
"updating report: " << report_name;
2933 if (report.
empty())
return;
2938 std::string str =
item->prefix();
2944 str =
item->postfix();
2969 int x = loc.x, y = loc.y;
2973 int image_count = 0;
2974 bool used_ellipsis =
false;
2975 std::ostringstream ellipsis_tooltip;
2976 SDL_Rect ellipsis_area = loc;
2979 elements.begin() != elements.end(); elements.pop_front())
2981 SDL_Rect area {x, y, loc.w + loc.x - x, loc.h + loc.y - y};
2982 if (area.h <= 0)
break;
2984 std::string
t = elements.front()[
"text"];
2987 if (used_ellipsis)
goto skip_element;
2992 if (
t[
t.size() - 1] ==
'\n') {
2994 t =
t.substr(0,
t.size() - 1);
3018 const int minimal_text = 12;
3020 if (!eol && loc.w - (x - loc.x + tsize.x) < minimal_text &&
3021 ++ee != elements.end() && !(*ee)[
"text"].empty())
3030 used_ellipsis =
true;
3031 ellipsis_area.x = x;
3032 ellipsis_area.y = y;
3033 ellipsis_area.w = tsize.x;
3034 ellipsis_area.h = tsize.y;
3039 if (!tooltip_test) {
3042 if (area.h > tallest) {
3053 else if (!(
t = elements.front()[
"image"].str()).empty())
3055 if (used_ellipsis)
goto skip_element;
3061 ERR_DP <<
"could not find image for report: '" <<
t <<
"'";
3065 if (area.w < img.
w() && image_count) {
3068 used_ellipsis =
true;
3071 if (img.
w() < area.w) area.w = img.
w();
3072 if (img.
h() < area.h) area.h = img.
h();
3073 if (!tooltip_test) {
3078 if (area.h > tallest) {
3082 if (!used_ellipsis) {
3085 ellipsis_area = area;
3095 t = elements.front()[
"tooltip"].t_str().c_str();
3097 if (tooltip_test && !used_ellipsis) {
3103 ellipsis_tooltip <<
t;
3105 if (++ee != elements.end())
3106 ellipsis_tooltip <<
"\n _________\n\n";
3111 if (tooltip_test && used_ellipsis) {
3120 const std::string& name = it.first;
3132 DBG_DP <<
"invalidate_all()";
3166 bool result =
false;
3169 std::set<map_location>::const_iterator
i = locs.begin();
3172 if (
i != locs.end()) {
3195 DBG_DP <<
"invalidating locations in " <<
rect;
3197 bool result =
false;
3207 if(
get_map().is_village(loc)) {
3209 if(owner >= 0 &&
flags_[owner].need_update()
3225 if(
builder_->update_animation(loc)) {
3234 u.anim_comp().refresh();
3237 u->anim_comp().refresh();
3244 new_inval |= u.anim_comp().invalidate(*
this);
3247 new_inval |= u->anim_comp().invalidate(*
this);
3257 u.anim_comp().set_standing();
3318 if (reach == full.end()) {
3321 }
else if (reach->second != 1) {
3334 if (reach_old->second != reach->second) {
void new_animation_frame()
Arrows destined to be drawn on the map.
std::vector< std::string > names
Definitions for the terrain builder.
void add_frame(int duration, const T &value, bool force_change=false)
Adds a frame to an animation.
Arrows destined to be drawn on the map.
const arrow_path_t & get_previous_path() const
const arrow_path_t & get_path() const
color_t rep() const
High-contrast shade, intended for the minimap markers.
A config object defines a single node in a WML file, with access to child nodes.
config & mandatory_child(config_key_type key, int n=0)
Returns the nth child with the given key, or throws an error if there is none.
config & add_child_at(config_key_type key, const config &val, std::size_t index)
child_itors child_range(config_key_type key)
boost::iterator_range< const_child_iterator > const_child_itors
config & add_child(config_key_type key)
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.
orb_status unit_orb_status(const unit &u) const
Returns an enumurated summary of whether this unit can move and/or attack.
int village_owner(const map_location &loc) const
Given the location of a village, will return the 1-based number of the team that currently owns it,...
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.
arrows_map_t arrows_map_
Maps the list of arrows for each location.
void unhide_buttons()
Unhide theme buttons so they draw again.
int xpos_
Position of the top-left corner of the viewport, in pixels.
bool map_screenshot_
Used to indicate to drawing functions that we are doing a map screenshot.
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.
static void add_submerge_ipf_mod(std::string &image_path, int image_height, double submersion_amount, int shift=0)
int viewing_side() const
The 1-based equivalent of the 0-based viewing_team() function.
void update_render_textures()
Ensure render textures are valid and correct.
static unsigned int last_zoom_
The previous value of zoom_.
void write(config &cfg) const
static bool zoom_at_min()
void get_terrain_images(const map_location &loc, const std::string &timeid, TERRAIN_TYPE terrain_type)
void remove_overlay(const map_location &loc)
remove_overlay will remove all overlays on a tile.
map_location selectedHex_
std::size_t viewing_team() const
The viewing team is the team currently viewing the game.
void recalculate_minimap()
Schedule the minimap for recalculation.
void redraw_minimap()
Schedule the minimap to be redrawn.
point get_location(const map_location &loc) const
unsigned int fps_counter_
bool invalidate_locations_in_rect(const SDL_Rect &rect)
invalidate all hexes under the rectangle rect (in screen coordinates)
const map_location hex_clicked_on(int x, int y) const
given x,y co-ordinates of an onscreen pixel, will return the location of the hex that this pixel corr...
virtual void render() override
Update offscreen render buffers.
void init_flags_for_side_internal(std::size_t side, const std::string &side_color)
void remove_single_overlay(const map_location &loc, const std::string &toDelete)
remove_single_overlay will remove a single overlay from a tile
static bool outside_area(const SDL_Rect &area, const int x, const int y)
Check if the bbox of the hex at x,y has pixels outside the area rectangle.
void fade_tod_mask(const std::string &old, const std::string &new_)
ToD mask smooth fade.
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
virtual const time_of_day & get_time_of_day(const map_location &loc=map_location::null_location()) const
void announce(const std::string &msg, const color_t &color=font::GOOD_COLOR, const announce_options &options=announce_options())
Announce a message prominently.
drawing_layer
The layers to render something on.
@ LAYER_UNIT_FIRST
Reserve layers to be selected for WML.
@ LAYER_TERRAIN_BG
Layer for the terrain drawn behind the unit.
@ LAYER_UNIT_DEFAULT
default layer for drawing units
@ LAYER_FOG_SHROUD
Fog and shroud.
@ LAYER_UNIT_MOVE_DEFAULT
default layer for drawing moving units
@ LAYER_GRID_BOTTOM
Used for the bottom half part of grid image.
@ LAYER_GRID_TOP
Top half part of grid image.
@ LAYER_TERRAIN_FG
Layer for the terrain drawn in front of the unit.
@ LAYER_REACHMAP
"black stripes" on unreachable hexes.
double turbo_speed() const
int current_frame_sample_
int invalidated_hexes_
Count work done for the debug info displayed under fps.
void adjust_color_overlay(int r, int g, int b)
Add r,g,b to the colors for all images displayed on the map.
bool add_exclusive_draw(const map_location &loc, unit &unit)
Allows a unit to request to be the only one drawn in its hex.
void set_fade(const color_t &color)
void queue_repaint()
Queues repainting to the screen, but doesn't rerender.
static int hex_size()
Function which returns the size of a hex in pixels (from top tip to bottom tip or left edge to right ...
int get_location_x(const map_location &loc) const
Functions to get the on-screen positions of hexes.
static double get_zoom_factor()
Returns the current zoom factor.
const rect & unit_image_area() const
bool scroll(int xmov, int ymov, bool force=false)
Scrolls the display by xmov,ymov pixels.
bool propagate_invalidation(const std::set< map_location > &locs)
If this set is partially invalidated, invalidate all its hexes.
void clear_redraw_observers()
Clear the redraw observers.
void invalidate_game_status()
Function to invalidate the game status displayed on the sidebar.
const theme::action * action_pressed()
std::shared_ptr< gui::button > find_action_button(const std::string &id)
Retrieves a pointer to a theme UI button.
void set_theme(const std::string &new_theme)
void rebuild_all()
Rebuild all dynamic terrain.
void change_display_context(const display_context *dc)
void add_redraw_observer(std::function< void(display &)> f)
Adds a redraw observer, a function object to be called when a full rerender is queued.
void set_prevent_draw(bool pd=true)
Prevent the game display from drawing.
virtual overlay_map & get_overlays()=0
virtual void layout() override
Finalize screen layout.
virtual void highlight_hex(map_location hex)
void update_tod(const time_of_day *tod_override=nullptr)
Applies r,g,b coloring to the map.
static bool zoom_at_max()
static display * singleton_
std::shared_ptr< gui::button > find_menu_button(const std::string &id)
void render_map_outside_area()
Draw/redraw the off-map background area.
void set_team(std::size_t team, bool observe=false)
Sets the team controlled by the player using the computer.
const map_location pixel_position_to_hex(int x, int y) const
given x,y co-ordinates of a pixel on the map, will return the location of the hex that this pixel cor...
void remove_arrow(arrow &)
@ DEBUG_COORDINATES
Overlays x,y coords on tiles.
@ DEBUG_BENCHMARK
Toggle to continuously redraw the whole map.
@ __NUM_DEBUG_FLAGS
Dummy entry to size the bitmask.
@ DEBUG_NUM_BITMAPS
Overlays number of bitmaps on tiles.
@ DEBUG_FOREGROUND
Separates background and foreground terrain layers.
@ DEBUG_TERRAIN_CODES
Overlays terrain codes on tiles.
void process_reachmap_changes()
void draw_minimap_units()
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.
void invalidate_animations_location(const map_location &loc)
Per-location invalidation called by invalidate_animations() Extra game per-location invalidation (vil...
map_location mouseoverHex_
bool fogged(const map_location &loc) const
Returns true if location (x,y) is covered in fog.
const gamemap & get_map() const
bool set_zoom(bool increase)
Zooms the display in (true) or out (false).
std::map< std::string, rect > reportLocations_
const rect_of_hexes get_visible_hexes() const
Returns the rectangular area of visible hexes.
texture get_flag(const map_location &loc)
void invalidate_all()
Function to invalidate all tiles.
std::map< std::string, config > reports_
std::bitset< __NUM_DEBUG_FLAGS > debug_flags_
Currently set debug flags.
SDL_Rect minimap_location_
map_location get_middle_location() const
void bounds_check_position()
std::function< rect(rect)> minimap_renderer_
surface screenshot(bool map_screenshot=false)
Capture a (map-)screenshot into a surface.
void init_flags()
Init the flag list and the team colors used by ~TC.
std::vector< std::shared_ptr< gui::button > > action_buttons_
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.
const rect_of_hexes hexes_under_rect(const SDL_Rect &r) const
Return the rectangular area of hexes overlapped by r (r is in screen coordinates)
void scroll_to_xy(int screenxpos, int screenypos, SCROLL_TYPE scroll_type, bool force=true)
rect map_outside_area() const
Returns the available area for a map, this may differ from the above.
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
bool tile_nearly_on_screen(const map_location &loc) const
Checks if location loc or one of the adjacent tiles is visible on screen.
void reload_map()
Updates internals that cache map size.
rect max_map_area() const
Returns the maximum area used for the map regardless to resolution and view size.
bool tile_fully_on_screen(const map_location &loc) const
Check if a tile is fully visible on screen.
map_location minimap_location_on(int x, int y)
given x,y co-ordinates of the mouse, will return the location of the hex in the minimap that the mous...
void scroll_to_tiles(map_location loc1, map_location loc2, SCROLL_TYPE scroll_type=ONSCREEN, bool check_fogged=true, double add_spacing=0.0, bool force=true)
Scroll such that location loc1 is on-screen.
bool is_blindfolded() const
std::vector< texture > terrain_image_vector_
std::vector< std::string > fog_images_
int fps_handle_
Handle for the label which displays frames per second.
bool invalidate_visible_locations_in_rect(const SDL_Rect &rect)
std::vector< std::function< void(display &)> > redraw_observers_
void read(const config &cfg)
const theme::menu * menu_pressed()
const std::unique_ptr< terrain_builder > builder_
std::vector< animated< image::locator > > flags_
Animated flags for each team.
static void fill_images_list(const std::string &prefix, std::vector< std::string > &images)
void draw_report(const std::string &report_name, bool test_run=false)
Draw the specified report.
std::set< map_location > invalidated_
std::vector< texture > get_fog_shroud_images(const map_location &loc, image::TYPE image_type)
void fade_to(const color_t &color, int duration)
Screen fade.
void queue_rerender()
Marks everything for rendering including all tiles and sidebar.
std::string remove_exclusive_draw(const map_location &loc)
Cancels an exclusive draw request.
bool invalidateGameStatus_
virtual void draw_invalidated()
Only called when there's actual redrawing to do.
void drawing_buffer_commit()
Draws the drawing_buffer_ and clears it.
rect map_area() const
Returns the area used for the map.
void draw_panel(const theme::panel &panel)
void set_playing_team(std::size_t team)
set_playing_team sets the team whose turn it currently is
std::chrono::seconds fps_start_
static int hex_width()
Function which returns the width of a hex in pixels, up to where the next hex starts.
void reset_standing_animations()
bool animate_water_
Local version of preferences::animate_water, used to detect when it's changed.
bool debug_flag_set(DEBUG_FLAG flag) const
void toggle_default_zoom()
Sets the zoom amount to the default.
virtual rect get_clip_rect() const
Get the clipping rectangle for drawing.
reports * reports_object_
bool draw_reports(const rect ®ion)
Draw all reports in the given region.
void invalidate_animations()
Function to invalidate animated terrains and units which may have changed.
virtual rect screen_location() override
Return the current draw location of the display, on the screen.
static const std::string & get_variant(const std::vector< std::string > &variants, const map_location &loc)
void hide_buttons()
Hide theme buttons so they don't draw.
virtual bool expose(const rect ®ion) override
Paint the indicated region to the screen.
std::list< draw_helper > drawing_buffer_
std::vector< std::shared_ptr< gui::button > > menu_buttons_
virtual void update() override
Update animations and internal state.
void draw()
Perform rendering of invalidated items.
int get_location_y(const map_location &loc) const
const rect & minimap_area() const
mapx is the width of the portion of the display which shows the game area.
events::generic_event scroll_event_
Event raised when the map is being scrolled.
bool show_everything() const
virtual void draw_hex(const map_location &loc)
Redraws a single gamemap location.
const rect & palette_area() const
std::map< map_location, unsigned int > reach_map
std::vector< std::tuple< int, int, int > > fps_history_
void reinit_flags_for_team(const team &)
Rebuild the flag list (not team colors) for a single side.
void draw_minimap()
Actually draw the minimap.
texture front_
Render textures, for intermediate rendering.
void update_arrow(arrow &a)
Called by arrow objects when they change.
void draw_label(const theme::label &label)
const std::unique_ptr< fake_unit_manager > fake_unit_man_
const display_context * dc_
bool animate_map_
Local cache for preferences::animate_map, since it is constantly queried.
std::vector< std::string > shroud_images_
static unsigned int zoom_
The current zoom, in pixels (on screen) per 72 pixels (in the graphic assets), i.e....
bool shrouded(const map_location &loc) const
Returns true if location (x,y) is covered in shroud.
void blindfold(bool flag)
void refresh_report(const std::string &report_name, const config *new_cfg=nullptr)
Update the given report.
std::weak_ptr< wb::manager > wb_
const std::unique_ptr< map_labels > map_labels_
boost::circular_buffer< unsigned > frametimes_
uint32_t last_frame_finished_
void set_diagnostic(const std::string &msg)
virtual void select_hex(map_location hex)
const std::vector< team > & get_teams() const
std::map< std::string, texture > reportSurfaces_
bool draw_all_panels(const rect ®ion)
Redraws all panels intersecting the given region.
void add_overlay(const map_location &loc, const std::string &image, const std::string &halo="", const std::string &team_name="", const std::string &item_id="", bool visible_under_fog=true, float submerge=0.0f, float z_order=0)
Functions to add and remove overlays from locations.
display(const display_context *dc, std::weak_ptr< wb::manager > wb, reports &reports_object, const std::string &theme_id, const config &level)
virtual void notify_observers()
Manages a list of fake units for the display object.
void set_lifetime(int lifetime, int fadeout=100)
void set_position(double xpos, double ypos)
void set_alignment(ALIGN align)
void set_color(const color_t &color)
void set_clip_rect(const SDL_Rect &r)
void set_font_size(int font_size)
pango_text & set_font_style(const FONT_STYLE font_style)
point get_size()
Returns the size of the text, in drawing coordinates.
pango_text & set_characters_per_line(const unsigned characters_per_line)
pango_text & set_foreground_color(const color_t &color)
pango_text & set_family_class(font::family_class fclass)
pango_text & set_ellipse_mode(const PangoEllipsizeMode ellipse_mode)
pango_text & set_alignment(const PangoAlignment alignment)
pango_text & set_font_size(unsigned font_size)
pango_text & set_link_aware(bool b)
bool set_text(const std::string &text, const bool markedup)
Sets the text to render.
pango_text & set_maximum_height(int height, bool multiline)
pango_text & set_maximum_width(int width)
texture render_and_get_texture()
Returns the cached texture, or creates a new one otherwise.
terrain_code get_terrain(const map_location &loc) const
Looks up terrain at a particular location.
int w() const
Effective map width.
int h() const
Effective map height.
bool on_board(const map_location &loc) const
Tell if a location is on the map.
const terrain_type & get_terrain_info(const t_translation::terrain_code &terrain) const
void update()
Process animations, remove deleted halos, and invalidate screen regions now requiring redraw.
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 'image centered on (x,y).
void render(const rect &r)
Render halos in region.
virtual void set_button_state()
Generic locator abstracting the location of an image.
A RAII object to temporary leave the synced context like in wesnoth.synchronize_choice.
void recalculate_shroud()
void set_team(const team *)
void recalculate_labels()
events::mouse_handler & get_mouse_handler_base() override
Get a reference to a mouse handler member a derived class uses.
hotkey::command_executor * get_hotkey_command_executor() override
Optionally get a command executor to handle context menu events.
static rng & default_instance()
config generate_report(const std::string &name, const context &ct, bool only_static=false)
An object to leave the synced context during draw or unsynced wml items when we don’t know whether we...
This class stores all the data for a single 'side' (in game nomenclature).
static color_t get_minimap_color(int side)
The class terrain_builder is constructed from a config object, and a gamemap object.
std::vector< animated< image::locator > > imagelist
A shorthand typedef for a list of animated image locators, the base data type returned by the get_ter...
TERRAIN_TYPE
Used as a parameter for the get_terrain_at function.
@ BACKGROUND
Represents terrains which are to be drawn behind unit sprites.
@ FOREGROUND
Represents terrains which are to be drawn in front of them.
double unit_submerge() const
Wrapper class to encapsulate creation and management of an SDL_Texture.
int w() const
The draw-space width of the texture, in pixels.
void reset()
Releases ownership of the managed texture and resets the ptr to null.
void set_src(const rect &r)
Set the source region of the texture used for drawing operations.
point draw_size() const
The size of the texture in draw-space.
void set_draw_size(int w, int h)
Set the intended size of the texture, in draw-space.
point get_raw_size() const
The raw internal texture size.
int h() const
The draw-space height of the texture, in pixels.
void set_alpha_mod(uint8_t alpha)
Alpha modifier.
void clear_src()
Clear the source region.
const std::string & get_id() const
virtual rect & location(const SDL_Rect &screen) const
const std::string & image() const
const border_t & border() const
static const config & get_theme_config(const std::string &id)
Returns the saved config for the theme with the given ID.
const rect & unit_image_location(const SDL_Rect &screen) const
const menu * get_menu_item(const std::string &key) const
const std::vector< action > & actions() const
const std::vector< menu > & menus() const
const rect & mini_map_location(const SDL_Rect &screen) const
const std::vector< panel > & panels() const
const rect & main_map_location(const SDL_Rect &screen) const
bool set_resolution(const SDL_Rect &screen)
const rect & palette_location(const SDL_Rect &screen) const
const status_item * get_status_item(const std::string &item) const
const std::vector< label > & labels() const
unit_iterator find(std::size_t id)
This class represents a single unit of a specific type.
constexpr uint8_t float_to_color(double n)
Convert a double in the range [0.0,1.0] to an 8-bit colour value.
void swap(config &lhs, config &rhs)
Implement non-member swap function for std::swap (calls config::swap).
static int get_zoom_levels_index(unsigned int zoom_level)
static unsigned calculate_fps(unsigned frametime)
static lg::log_domain log_display("display")
static SDL_Renderer * renderer()
Drawing functions, for drawing things on the screen.
Declarations for File-IO.
const std::string & id() const
Gets this unit's id.
std::string label
What to show in the filter's drop-down list.
std::string id
Text to match against addon_info.tags()
void get_adjacent_tiles(const map_location &a, map_location *res)
Function which, given a location, will place all adjacent locations in res.
static std::ostream & output()
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...
constexpr bool is_odd(T num)
void invalidate_region(const rect ®ion)
Mark a region of the screen as requiring redraw.
void invalidate_all()
Mark the entire screen as requiring redraw.
render_target_setter set_render_target(const texture &t)
Set the given texture as the active render target.
clip_setter override_clip(const SDL_Rect &clip)
Override the clipping area.
clip_setter reduce_clip(const SDL_Rect &clip)
Set the clipping area to the intersection of the current clipping area and the given rectangle.
void tiled(const texture &tex, const SDL_Rect &dst, bool centered=false, bool mirrored=false)
Tile a texture to fill a region.
void fill(const SDL_Rect &rect, uint8_t r, uint8_t g, uint8_t b, uint8_t a)
Fill an area with the given colour.
void blit(const texture &tex, const SDL_Rect &dst)
Draws a texture, or part of a texture, at the given location.
::rect get_clip()
Get the current clipping area, in draw coordinates.
void rect(const SDL_Rect &rect)
Draw a rectangle.
EXIT_STATUS start(bool clear_id, const std::string &filename, bool take_screenshot, const std::string &screenshot_filename)
Main interface for launching the editor from the title screen.
void draw()
Trigger a draw cycle.
void pump_and_draw()
pump() then immediately draw()
void pump()
Process all events currently in the queue.
std::string get_user_data_dir()
filesystem::scoped_ostream ostream_file(const std::string &fname, std::ios_base::openmode mode, bool create_directory)
std::unique_ptr< std::ostream > scoped_ostream
const int SIZE_FLOAT_LABEL
const color_t YELLOW_COLOR
pango_text & get_text_renderer()
Returns a reference to a static pango_text object.
int add_floating_label(const floating_label &flabel)
add a label floating on the screen above everything else.
void remove_floating_label(int handle, int fadeout)
removes the floating label given by 'handle' from the screen
const int SIZE_BUTTON_SMALL
rect pango_draw_text(bool actually_draw, const rect &area, int size, const color_t &color, const std::string &text, int x, int y, bool use_tooltips, pango_text::FONT_STYLE style)
Draws text on the screen.
void scroll_floating_labels(double xmove, double ymove)
moves all floating labels that have 'scroll_mode' set to ANCHOR_LABEL_MAP
void update_floating_labels()
void draw_floating_labels()
const color_t NORMAL_COLOR
const color_range & color_info(std::string_view name)
std::string shroud_prefix
std::shared_ptr< halo_record > handle
std::pair< std::string, unsigned > item
Functions to load and save images from/to disk.
bool exists(const image::locator &i_locator)
Returns true if the given image actually exists, without loading it.
std::function< rect(rect)> prep_minimap_for_rendering(const gamemap &map, const team *vw, const unit_map *units, const std::map< map_location, unsigned int > *reach_map, bool ignore_terrain_disabled)
Prepares the minimap texture and returns a function which will render it to the current rendering tar...
texture get_lighted_texture(const image::locator &i_locator, const light_string &ls)
std::basic_string< signed char > light_string
Type used to store color information of central and adjacent hexes.
TYPE
Used to specify the rendering format of images.
@ HEXED
Standard hexagonal tile mask applied, removing portions that don't fit.
@ TOD_COLORED
Same as HEXED, but with Time of Day color tint applied.
texture get_texture(const image::locator &i_locator, TYPE type, bool skip_cache)
Returns an image texture suitable for hardware-accelerated rendering.
point get_size(const locator &i_locator, bool skip_cache)
Returns the width and height of an image.
void set_color_adjustment(int r, int g, int b)
Changes Time of Day color tint for all applicable image types.
light_string get_light_string(int op, int r, int g, int b)
Returns the light_string for one light operation.
const std::vector< std::string > items
std::string get_orb_color(orb_status os)
Wrapper for the various preferences::unmoved_color(), moved_color(), etc methods, using the enum inst...
Modify, read and display user preferences.
bool minimap_movement_coding()
void set_tile_size(const unsigned int size)
bool minimap_draw_units()
Unit and team statistics.
::tod_manager * tod_manager
fake_unit_manager * fake_units
play_controller * controller
constexpr const SDL_Rect empty_rect
std::size_t index(const std::string &str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
void trim(std::string_view &s)
bool contains(const Container &container, const Value &value)
Returns true iff value is found in container.
std::vector< std::string > square_parenthetical_split(const std::string &val, const char separator, const std::string &left, const std::string &right, const int flags)
Similar to parenthetical_split, but also expands embedded square brackets.
std::vector< std::string > split(const config_attribute_value &val)
bool headless()
The game is running headless.
surface read_pixels(SDL_Rect *r)
Copy back a portion of the render target that is already drawn.
rect game_canvas()
The game canvas area, in drawing coordinates.
int get_pixel_scale()
Get the current active pixel scale multiplier.
int current_refresh_rate()
The refresh rate of the screen.
std::string::const_iterator iterator
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
@ allied
Belongs to a friendly side.
@ enemy
Belongs to a non-friendly side; normally visualised by not displaying an orb.
Transitional API for porting SDL_ttf-based code to Pango.
The basic class for representing 8-bit RGB or RGBA colour values.
constexpr color_t smooth_blend(const color_t &c, uint8_t p) const
Blend smoothly with another color_t.
Holds options for calls to function 'announce' (announce).
Helper for rendering the map by ordering draw operations.
std::function< void(const rect &)> do_draw
Handles the actual drawing at this location.
very simple iterator to walk into the rect_of_hexes
iterator & operator++()
increment y first, then when reaching bottom, increment x
const rect_of_hexes & rect_
Rectangular area of hexes, allowing to decide how the top and bottom edges handles the vertical shift...
Encapsulates the map of the game.
void write(config &cfg) const
An abstract description of a rectangle with integer coordinates.
bool empty() const
False if both w and h are > 0, true otherwise.
bool contains(int x, int y) const
Whether the given point lies within the rectangle.
void clip(const SDL_Rect &r)
Clip this rectangle by the given rectangle.
rect intersect(const SDL_Rect &r) const
Calculates the intersection of this rectangle and another; that is, the maximal rectangle that is con...
bool overlaps(const SDL_Rect &r) const
Whether the given rectangle and this rectangle overlap.
A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separa...
std::string background_image
Object which defines a time of day with associated bonuses, image, sounds etc.
tod_color color
The color modifications that should be made to the game board to reflect the time of day.
std::string image_mask
The image that is to be laid over all images while this time of day lasts.
Small struct to store and manipulate ToD color adjusts.
static map_location::DIRECTION n
static map_location::DIRECTION s