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;
301 for(
const std::string&
item : items) {
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),
1543 if(time_between_draws < 0) {
1549 using std::chrono::duration_cast;
1550 using std::chrono::seconds;
1551 using std::chrono::steady_clock;
1552 const seconds current_second = duration_cast<seconds>(steady_clock::now().time_since_epoch());
1565 if((*i)->pressed()) {
1581 if((*i)->pressed()) {
1645 ERR_DP <<
"trying to draw null minimap";
1670 double shift_x = -border *
hex_width() - (map_out_rect.w - map_rect.w) / 2;
1671 double shift_y = -(border + 0.25) *
hex_size() - (map_out_rect.h - map_rect.h) / 2;
1673 int view_x =
static_cast<int>((
xpos_ + shift_x) * xscaling);
1674 int view_y =
static_cast<int>((
ypos_ + shift_y) * yscaling);
1675 int view_w =
static_cast<int>(map_out_rect.w * xscaling);
1676 int view_h =
static_cast<int>(map_out_rect.h * yscaling);
1678 SDL_Rect outline_rect {
1695 for(
const auto& u :
dc_->
units()) {
1696 if (
fogged(u.get_location()) ||
1698 u.invisible(u.get_location())) ||
1703 int side = u.side();
1706 if(!
prefs::get().minimap_movement_coding()) {
1710 }
else if(
currentTeam_ + 1 ==
static_cast<unsigned>(side)) {
1718 double u_x = u.get_location().x * xscaling;
1719 double u_y = (u.get_location().y + (
is_odd(u.get_location().x) ? 1 : -1)/4.0) * yscaling;
1721 double u_w = 4.0 / 3.0 * xscaling;
1722 double u_h = yscaling;
1727 , int(std::round(u_w))
1728 , int(std::round(u_h))
1742 if(xmove == 0 && ymove == 0) {
1746 int new_x =
xpos_ + xmove;
1747 int new_y =
ypos_ + ymove;
1756 const int diff_x =
xpos_ - new_x;
1757 const int diff_y =
ypos_ - new_y;
1810 r.y = r.y + r.h + diff_y;
1813 r.h = std::abs(diff_y);
1821 r.x = r.x + r.w + diff_x;
1824 r.w = std::abs(diff_x);
1859 LOG_DP <<
"new_zoom = " << new_zoom;
1861 if(new_zoom ==
zoom_) {
1865 if(validate_value_and_set_index) {
1870 if((new_zoom / 4) * 4 != new_zoom) {
1871 WRN_DP <<
"set_zoom forcing zoom " << new_zoom
1872 <<
" which is not a multiple of 4."
1873 <<
" This will likely cause graphical glitches.";
1880 double zoom_factor =
static_cast<double>(new_zoom) /
static_cast<double>(
zoom_);
1894 xpos_ = std::round(((
xpos_ + area.w / 2) * zoom_factor) - (area.w / 2));
1895 ypos_ = std::round(((
ypos_ + area.h / 2) * zoom_factor) - (area.h / 2));
1939 return x + hs >= area.x - hw && x < area.x + area.w + hw &&
1940 y + hs >= area.y - hs && y < area.y + area.h + hs;
1950 const int xmove_expected = screenxpos - (area.x + area.w/2);
1951 const int ymove_expected = screenypos - (area.y + area.h/2);
1953 int xpos =
xpos_ + xmove_expected;
1954 int ypos =
ypos_ + ymove_expected;
1956 int xmove = xpos -
xpos_;
1957 int ymove = ypos -
ypos_;
1960 scroll(xmove,ymove,
true);
1971 const double dist_total = std::hypot(xmove, ymove);
1972 double dist_moved = 0.0;
1974 int t_prev = SDL_GetTicks();
1976 double velocity = 0.0;
1977 while (dist_moved < dist_total) {
1980 int t = SDL_GetTicks();
1981 double dt = (
t - t_prev) / 1000.0;
1993 double accel = velocity_max / accel_time;
1994 double decel = velocity_max / decel_time;
1997 double stop_time = velocity / decel;
1998 double dist_stop = dist_moved + velocity*stop_time - 0.5*decel*stop_time*stop_time;
1999 if (dist_stop > dist_total || velocity > velocity_max) {
2000 velocity -= decel * dt;
2001 if (velocity < 1.0) velocity = 1.0;
2003 velocity += accel * dt;
2004 if (velocity > velocity_max) velocity = velocity_max;
2007 dist_moved += velocity * dt;
2008 if (dist_moved > dist_total) dist_moved = dist_total;
2010 int x_new = std::round(xmove * dist_moved / dist_total);
2011 int y_new = std::round(ymove * dist_moved / dist_total);
2013 int dx = x_new - x_old;
2014 int dy = y_new - y_old;
2027 if(
get_map().on_board(loc) ==
false) {
2028 ERR_DP <<
"Tile at " << loc <<
" isn't on the map, can't scroll to the tile.";
2032 std::vector<map_location> locs;
2033 locs.push_back(loc);
2039 double add_spacing,
bool force)
2041 std::vector<map_location> locs;
2042 locs.push_back(loc1);
2043 locs.push_back(loc2);
2044 scroll_to_tiles(locs, scroll_type, check_fogged,
false, add_spacing,force);
2048 const std::vector<map_location>::const_iterator &
end,
2050 bool only_if_possible,
double add_spacing,
bool force)
2059 for(std::vector<map_location>::const_iterator itor =
begin; itor !=
end ; ++itor) {
2060 if(
get_map().on_board(*itor) ==
false)
continue;
2061 if(check_fogged &&
fogged(*itor))
continue;
2073 int minx_new = std::min<int>(minx,x);
2074 int miny_new = std::min<int>(miny,y);
2075 int maxx_new = std::max<int>(maxx,x);
2076 int maxy_new = std::max<int>(maxy,y);
2082 if (only_if_possible)
return;
2096 int spacing = std::round(add_spacing *
hex_size());
2110 locs_bbox.w = maxx - minx +
hex_size();
2111 locs_bbox.h = maxy - miny +
hex_size();
2114 int target_x = locs_bbox.x + locs_bbox.w/2;
2115 int target_y = locs_bbox.y + locs_bbox.h/2;
2120 int map_center_x = r.x + r.w/2;
2121 int map_center_y = r.y + r.h/2;
2127 double inside_frac = 0.5;
2128 w =
static_cast<int>(
w * inside_frac);
2129 h =
static_cast<int>(
h * inside_frac);
2139 r.x = target_x -
w/2;
2140 r.y = target_y -
h/2;
2148 if (map_center_x < r.x) {
2150 target_y = std::clamp(map_center_y, r.y, r.y + r.h - 1);
2151 }
else if (map_center_x > r.x+r.w-1) {
2152 target_x = r.x + r.w - 1;
2153 target_y = std::clamp(map_center_y, r.y, r.y + r.h - 1);
2154 }
else if (map_center_y < r.y) {
2156 target_x = std::clamp(map_center_x, r.x, r.x + r.w - 1);
2157 }
else if (map_center_y > r.y+r.h-1) {
2158 target_y = r.y + r.h - 1;
2159 target_x = std::clamp(map_center_x, r.x, r.x + r.w - 1);
2161 ERR_DP <<
"Bug in the scrolling code? Looks like we would not need to scroll after all...";
2184 xpos = std::clamp(xpos, 0, xend -
map_area().
w);
2185 ypos = std::clamp(ypos, 0, yend -
map_area().
h);
2191 if(
keys_[SDLK_LSHIFT] ||
keys_[SDLK_RSHIFT]) {
2219 if(submerge <= 0.0) {
2224 data.unsub_dest = dest;
2225 const int dest_sub_h = dest.h * submerge;
2226 data.unsub_dest.h -= dest_sub_h;
2227 const int dest_y_mid = dest.y +
data.unsub_dest.h;
2230 const int submersion_line =
size.y * (1.0 - submerge);
2231 data.unsub_src = {0, 0,
size.x, submersion_line};
2234 const color_t c_mid(255, 255, 255, 0.3 * alpha);
2235 const int pixels_submerged =
size.y * submerge;
2236 const int bot_alpha = std::max(0.3 - pixels_submerged * 0.015, 0.0) * alpha;
2237 const color_t c_bot(255, 255, 255, bot_alpha);
2238 const SDL_FPoint pML{float(dest.x), float(dest_y_mid)};
2239 const SDL_FPoint pMR{float(dest.x + dest.w), float(dest_y_mid)};
2240 const SDL_FPoint pBL{float(dest.x), float(dest.y + dest.h)};
2241 const SDL_FPoint pBR{float(dest.x + dest.w), float(dest.y + dest.h)};
2242 data.alpha_verts = {
2243 SDL_Vertex{pML, c_mid, {0.0, float(1.0 - submerge)}},
2244 SDL_Vertex{pMR, c_mid, {1.0, float(1.0 - submerge)}},
2245 SDL_Vertex{pBL, c_bot, {0.0, 1.0}},
2246 SDL_Vertex{pBR, c_bot, {1.0, 1.0}},
2250 for(SDL_Vertex& v :
data.alpha_verts) {
2251 v.tex_coord.x = 1.0 - v.tex_coord.x;
2255 for(SDL_Vertex& v :
data.alpha_verts) {
2256 v.tex_coord.y = 1.0 - v.tex_coord.y;
2264 const std::string& old_mask,
2265 const std::string& new_mask)
2272 int start = SDL_GetTicks();
2273 for(
int now =
start; now <
start + duration; now = SDL_GetTicks()) {
2274 float prop_f = float(now -
start) / float(duration);
2288 uint32_t
start = SDL_GetTicks();
2293 if(fade_start.a == 0) {
2294 fade_start.r = fade_end.r;
2295 fade_start.g = fade_end.g;
2296 fade_start.b = fade_end.b;
2300 if(fade_end.a == 0) {
2301 fade_end.r = fade_start.r;
2302 fade_end.g = fade_start.g;
2303 fade_end.b = fade_start.b;
2307 for(uint32_t now =
start; now <
start + duration; now = SDL_GetTicks()) {
2308 float prop_f = float(now -
start) / float(duration);
2329 DBG_DP <<
"redrawing everything";
2352 if(command_executor !=
nullptr) {
2396 DBG_DP <<
"display::draw denied";
2407 DBG_DP <<
"display::draw redraw background";
2460 DBG_DP <<
"draw() with invalidateAll";
2485 DBG_DP <<
"render prevented";
2499 ERR_DP <<
"error creating minimap";
2508 DBG_DP <<
"draw prevented";
2543 DBG_DP <<
"display::expose " << region;
2573 bool raw_size_changed =
size.x != oarea.w ||
size.y != oarea.h;
2574 bool draw_size_changed = dsize.x != darea.w || dsize.y != darea.h;
2575 if (!raw_size_changed && !draw_size_changed) {
2580 if(raw_size_changed) {
2581 LOG_DP <<
"regenerating render buffers as " << oarea;
2582 front_ =
texture(oarea.w, oarea.h, SDL_TEXTUREACCESS_TARGET);
2583 back_ =
texture(oarea.w, oarea.h, SDL_TEXTUREACCESS_TARGET);
2585 if(raw_size_changed || draw_size_changed) {
2586 LOG_DP <<
"updating render buffer draw size to " << darea;
2592 for(
int i = 0;
i < 2; ++
i) {
2609 for(
int i = 0;
i < 2; ++
i) {
2640 DBG_DP <<
"drawing " <<
invalidated_.size() <<
" invalidated hexes with clip " << clip_rect;
2643 utils::optional<unit_drawer> drawer{};
2645 drawer.emplace(*
this);
2653 if(!hex_rect.
overlaps(clip_rect)) {
2665 drawer->redraw_unit(*u_it);
2680 int num_images_fg = 0;
2681 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;
2742 texture tex = ov.image.find(
"~NO_TOD_SHIFT()") == std::string::npos
2753 if(submerge > 0.0) {
2777 const std::string& tod_hex_mask = tod.
image_mask;
2786 }
else if(!tod_hex_mask.empty()) {
2792 arrows_map_t::const_iterator arrows_in_hex =
arrows_map_.find(loc);
2794 for (
arrow*
const a : arrows_in_hex->second) {
2839 std::ostringstream ss;
2849 ss << (num_images_bg + num_images_fg) <<
'\n';
2852 std::string
output = ss.str();
2862 renderer.set_alignment(PANGO_ALIGN_CENTER);
2864 renderer.set_maximum_height(-1,
false);
2868 const rect text_dest {
2869 (dest.x + dest.w / 2) - (tex.w() / 2),
2870 (dest.y + dest.h / 2) - (tex.h() / 2),
2876 const rect bg_dest {
2915 if ( new_cfg ==
nullptr )
2916 new_cfg = &generated_cfg;
2923 if (loc == new_loc && report == *new_cfg) {
2927 DBG_DP <<
"updating report: " << report_name;
2941 if (report.
empty())
return;
2946 std::string str =
item->prefix();
2952 str =
item->postfix();
2977 int x = loc.x, y = loc.y;
2981 int image_count = 0;
2982 bool used_ellipsis =
false;
2983 std::ostringstream ellipsis_tooltip;
2984 SDL_Rect ellipsis_area = loc;
2987 elements.begin() != elements.end(); elements.pop_front())
2989 SDL_Rect area {x, y, loc.w + loc.x - x, loc.h + loc.y - y};
2990 if (area.h <= 0)
break;
2992 std::string
t = elements.front()[
"text"];
2995 if (used_ellipsis)
goto skip_element;
3000 if (
t[
t.size() - 1] ==
'\n') {
3002 t =
t.substr(0,
t.size() - 1);
3026 const int minimal_text = 12;
3028 if (!eol && loc.w - (x - loc.x + tsize.x) < minimal_text &&
3029 ++ee != elements.end() && !(*ee)[
"text"].empty())
3038 used_ellipsis =
true;
3039 ellipsis_area.x = x;
3040 ellipsis_area.y = y;
3041 ellipsis_area.w = tsize.x;
3042 ellipsis_area.h = tsize.y;
3047 if (!tooltip_test) {
3050 if (area.h > tallest) {
3061 else if (!(
t = elements.front()[
"image"].str()).empty())
3063 if (used_ellipsis)
goto skip_element;
3069 ERR_DP <<
"could not find image for report: '" <<
t <<
"'";
3073 if (area.w < img.
w() && image_count) {
3076 used_ellipsis =
true;
3079 if (img.
w() < area.w) area.w = img.
w();
3080 if (img.
h() < area.h) area.h = img.
h();
3081 if (!tooltip_test) {
3086 if (area.h > tallest) {
3090 if (!used_ellipsis) {
3093 ellipsis_area = area;
3103 t = elements.front()[
"tooltip"].t_str().c_str();
3105 if (tooltip_test && !used_ellipsis) {
3111 ellipsis_tooltip <<
t;
3113 if (++ee != elements.end())
3114 ellipsis_tooltip <<
"\n _________\n\n";
3119 if (tooltip_test && used_ellipsis) {
3128 const std::string& name = it.first;
3140 DBG_DP <<
"invalidate_all()";
3174 bool result =
false;
3177 std::set<map_location>::const_iterator
i = locs.begin();
3180 if (
i != locs.end()) {
3203 DBG_DP <<
"invalidating locations in " <<
rect;
3205 bool result =
false;
3215 if(
get_map().is_village(loc)) {
3217 if(owner >= 0 &&
flags_[owner].need_update()
3233 if(
builder_->update_animation(loc)) {
3242 u.anim_comp().refresh();
3245 u->anim_comp().refresh();
3252 new_inval |= u.anim_comp().invalidate(*
this);
3255 new_inval |= u->anim_comp().invalidate(*
this);
3265 u.anim_comp().set_standing();
3326 if (reach == full.end()) {
3329 }
else if (reach->second != 1) {
3342 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.
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()
static submerge_data get_submerge_data(const rect &dest, double submerge, const point &size, uint8_t alpha, bool hreverse, bool vreverse)
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 prefs::get().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 prefs::get().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.
void set_tile_size(const unsigned int size)
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 NOT_DANGLING 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 ALPHA_OPAQUE
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")
map_display and display: classes which take care of displaying the map and game-data on the screen.
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.
void smooth_shaded(const texture &tex, const SDL_Rect &dst, const SDL_Color &cTL, const SDL_Color &cTR, const SDL_Color &cBL, const SDL_Color &cBR, const SDL_FPoint &uvTL, const SDL_FPoint &uvTR, const SDL_FPoint &uvBL, const SDL_FPoint &uvBR)
Draw a texture with smoothly varying colour and alpha modification, specified at the four corners of ...
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.
std::string get_orb_color(orb_status os)
Wrapper for the various prefs::get().unmoved_color(), moved_color(), etc methods, using the enum inst...
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).
bool discard_previous
An announcement according these options should replace the previous announce (typical of fast announc...
int lifetime
Lifetime measured in milliseconds.
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