59 #include <boost/algorithm/string/trim.hpp>
61 #include <SDL2/SDL_image.h>
77 #define ERR_DP LOG_STREAM(err, log_display)
78 #define WRN_DP LOG_STREAM(warn, log_display)
79 #define LOG_DP LOG_STREAM(info, log_display)
80 #define DBG_DP LOG_STREAM(debug, log_display)
83 #define zoom_levels (game_config::zoom_levels)
84 #define final_zoom_index (static_cast<int>(zoom_levels.size()) - 1)
85 #define DefaultZoom (game_config::tile_size)
86 #define SmallZoom (DefaultZoom / 2)
87 #define MinZoom (zoom_levels.front())
88 #define MaxZoom (zoom_levels.back())
106 float diff = *iter - *(iter - 1);
107 float lower = (zoom_level - *(iter - 1)) / diff;
108 float upper = (*iter - zoom_level) / diff;
119 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)
128 auto it = std::find_if(overlays.begin(), overlays.end(), [z_order](
const overlay& ov) { return ov.z_order > z_order; });
129 overlays.emplace(it, img,
halo, halo_handle, team_name, item_id, visible_under_fog, submerge, z_order);
142 overlays.begin(), overlays.end(),
143 [&toDelete](
const overlay& ov) { return ov.image == toDelete || ov.halo == toDelete || ov.id == toDelete; }
150 std::weak_ptr<wb::manager>
wb,
152 const std::string& theme_id,
157 , exclusive_unit_draw_requests_()
159 , dont_show_all_(false)
162 , view_locked_(false)
166 , builder_(new
terrain_builder(
level, (dc_ ? &dc_->map() : nullptr), theme_.border().tile_image, theme_.border().show_border))
169 , redraw_background_(false)
170 , invalidateAll_(true)
171 , diagnostic_label_(0)
172 , invalidateGameStatus_(true)
174 , reports_object_(&reports_object)
175 , scroll_event_(
"scrolled")
186 , tod_hex_mask1(nullptr)
187 , tod_hex_mask2(nullptr)
194 , animate_water_(true)
198 , map_screenshot_(false)
201 , reach_map_changed_(true)
203 , invalidated_hexes_(0)
205 , redraw_observers_()
224 if(tile_size < MinZoom || tile_size >
MaxZoom)
270 std::vector<std::string> side_colors;
271 side_colors.reserve(
dc_->
teams().size());
274 std::string side_color =
t.color();
275 side_colors.push_back(side_color);
287 assert(
dc_ !=
nullptr);
288 assert(n < dc_->teams().
size());
293 std::string new_rgb = side_color;
299 LOG_DP <<
"Adding flag for team " <<
n <<
" from animation " <<
flag;
308 std::string str =
item;
311 if(sub_items.size() > 1) {
312 str = sub_items.front();
314 time = std::max<int>(1, std::stoi(sub_items.back()));
315 }
catch(
const std::invalid_argument&) {
316 ERR_DP <<
"Invalid time value found when constructing flag for side " <<
n <<
": " << sub_items.back();
320 std::stringstream temp;
321 temp << str <<
"~RC(" << old_rgb <<
">"<< new_rgb <<
")";
328 auto time =
f.get_end_time();
334 ERR_DP <<
"missing flag for team" <<
n;
340 if(!
get_map().is_village(loc)) {
348 flag.update_last_draw_time();
350 flag.get_current_frame() :
flag.get_first_frame();
360 assert(teamindex < dc_->teams().
size());
370 if(std::shared_ptr<wb::manager>
w =
wb_.lock()) {
371 w->on_viewer_change(teamindex);
377 assert(teamindex < dc_->teams().
size());
437 std::ostringstream
s;
443 images.push_back(
s.str());
448 images.emplace_back();
454 return variants[std::abs(loc.
x + loc.
y) % variants.size()];
504 rect max_area{0, 0, 0, 0};
530 if(max_area.w < res.w) {
532 res.x += (res.w - max_area.w) / 2;
536 if(max_area.h < res.h) {
538 res.y += (res.h - max_area.h) / 2;
558 return (x < area.x || x > area.x + area.w - x_thresh || y < area.y || y > area.y + area.h - y_thresh);
584 const int offset = y < 0 ? 1 : 0;
590 const int tesselation_x_size =
hex_width() * 2;
591 const int tesselation_y_size =
s;
592 const int x_base = x / tesselation_x_size * 2;
593 const int x_mod = x % tesselation_x_size;
594 const int y_base = y / tesselation_y_size;
595 const int y_mod = y % tesselation_y_size;
600 if (y_mod < tesselation_y_size / 2) {
601 if ((x_mod * 2 + y_mod) < (
s / 2)) {
604 }
else if ((x_mod * 2 - y_mod) < (
s * 3 / 2)) {
613 if ((x_mod * 2 - (y_mod -
s / 2)) < 0) {
616 }
else if ((x_mod * 2 + (y_mod -
s / 2)) <
s * 2) {
625 return map_location(x_base + x_modifier - offset, y_base + y_modifier - offset);
654 if(r.w <= 0 || r.h <= 0) {
667 int x =
xpos_ - map_rect.x + r.x;
668 int y =
ypos_ - map_rect.y + r.y;
678 res.
left =
static_cast<int>(std::floor(-border + x / tile_width - 0.3333333));
681 res.
right =
static_cast<int>(std::floor(-border + (x + r.w - 1) / tile_width));
685 res.
top[0] =
static_cast<int>(std::floor(-border + y /
tile_size));
686 res.
top[1] =
static_cast<int>(std::floor(-border + y /
tile_size - 0.5));
687 res.
bottom[0] =
static_cast<int>(std::floor(-border + (y + r.h - 1) /
tile_size));
688 res.
bottom[1] =
static_cast<int>(std::floor(-border + (y + r.h - 1) /
tile_size - 0.5));
764 if (!map_screenshot) {
765 LOG_DP <<
"taking ordinary screenshot";
770 ERR_DP <<
"No map loaded, cannot create a map screenshot.";
775 int old_xpos =
xpos_;
776 int old_ypos =
ypos_;
782 if (area.w > 1 << 16 || area.h > 1 << 16) {
783 WRN_DP <<
"Excessively large map screenshot area";
785 LOG_DP <<
"creating " << area.w <<
" by " << area.h
786 <<
" texture for map screenshot";
787 texture output_texture(area.w, area.h, SDL_TEXTUREACCESS_TARGET);
828 DBG_DP <<
"positioning menu buttons...";
832 b->set_location(loc);
833 b->set_measurements(0,0);
834 b->set_label(menu.title());
835 b->set_image(menu.image());
839 DBG_DP <<
"positioning action buttons...";
843 b->set_location(loc);
844 b->set_measurements(0,0);
845 b->set_label(action.title());
846 b->set_image(action.image());
855 if(
type ==
"checkbox") {
857 }
else if(
type ==
"image") {
859 }
else if(
type ==
"radiobox") {
861 }
else if(
type ==
"turbo") {
868 const std::string& get_direction(std::size_t
n)
870 using namespace std::literals::string_literals;
871 static const std::array dirs{
"-n"s,
"-ne"s,
"-se"s,
"-s"s,
"-sw"s,
"-nw"s};
872 return dirs[
n >= dirs.size() ? 0 :
n];
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());
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());
929 DBG_DP <<
"buttons created";
956 std::vector<std::string>
names;
959 enum visibility { FOG = 0, SHROUD = 1, CLEAR = 2 };
960 std::array<visibility, 6> tiles;
964 for(
int i = 0;
i < 6; ++
i) {
974 for(
int v = FOG; v != CLEAR; ++v) {
978 if(tiles[
start] != v) {
986 const std::string name = *image_prefix[v] +
"-all.png";
988 names.push_back(name);
998 for(
int i = (
start + 1) % 6, cap1 = 0;
i !=
start && cap1 != 6; ++cap1) {
1000 std::ostringstream stream;
1002 stream << *image_prefix[v];
1004 for(
int cap2 = 0; v == tiles[
i] && cap2 != 6;
i = (
i + 1) % 6, ++cap2) {
1005 stream << get_direction(
i);
1015 name = stream.str();
1020 names.push_back(name +
".png");
1029 std::vector<texture> res;
1031 for(
const std::string& name :
names) {
1033 res.push_back(std::move(tex));
1049 std::array<
const time_of_day*, adjs.size()> atods;
1051 for(std::size_t
d = 0;
d < adjs.size(); ++
d) {
1055 for(
int d = 0;
d < 6; ++
d) {
1087 for(
int d = 0;
d < 6; ++
d) {
1119 for(
int d = 0;
d < 6; ++
d) {
1166 for(
const auto& terrain : *terrains) {
1174 const bool off_map = (
image.get_filename() == off_map_name
1175 ||
image.get_modifications().find(
"NO_TOD_SHIFT()") != std::string::npos);
1179 }
else if(lt.empty()) {
1194 constexpr std::array layer_groups {
1209 BITS_FOR_LAYER_GROUP = 4,
1215 BITS_FOR_X_PARITY = 1,
1221 BITS_FOR_X_OVER_2 = 9,
1223 SHIFT_LAYER = BITS_FOR_X_OVER_2,
1225 SHIFT_X_PARITY = BITS_FOR_LAYER + SHIFT_LAYER,
1227 SHIFT_Y = BITS_FOR_X_PARITY + SHIFT_X_PARITY,
1229 SHIFT_LAYER_GROUP = BITS_FOR_Y + SHIFT_Y
1235 uint32_t group_i = layer_groups.size() - 1;
1238 while(layer < layer_groups[group_i]) {
1246 const uint32_t x_parity =
static_cast<uint32_t
>(loc.
x) & 1;
1249 static_assert(SHIFT_LAYER_GROUP + BITS_FOR_LAYER_GROUP ==
sizeof(key) * 8,
"Bit field too small");
1251 key = (group_i << SHIFT_LAYER_GROUP) | (static_cast<uint32_t>(loc.
y + MAX_BORDER) << SHIFT_Y);
1252 key |= (x_parity << SHIFT_X_PARITY);
1253 key |= (
static_cast<uint32_t
>(layer) << SHIFT_LAYER) |
static_cast<uint32_t
>(loc.
x + MAX_BORDER) / 2;
1270 drawing_buffer_.emplace_back(generate_hex_key(layer, loc), draw_func, dest);
1272 draw_helper temp{generate_hex_key(layer, loc), draw_func, dest};
1297 std::invoke(helper.do_draw, helper.dest);
1306 return frametime != 0u ? 1000u / frametime : 999u;
1312 const int sample_freq = 10;
1331 *fps_log << std::get<0>(fps) <<
"," << std::get<1>(fps) <<
"," << std::get<2>(fps) <<
"\n";
1340 std::ostringstream stream;
1341 stream <<
"<tt> min/avg/max/act</tt>\n";
1342 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";
1343 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";
1374 if (panel.
image().empty()) {
1384 DBG_DP <<
"drawing panel " << panel.
get_id() <<
' ' << loc;
1389 <<
" texture: " << panel.
image();
1404 const std::string& text =
label.text();
1406 const std::string& icon =
label.icon();
1408 DBG_DP <<
"drawing label " <<
label.get_id() <<
' ' << loc;
1410 if(icon.empty() ==
false) {
1413 if(text.empty() ==
false) {
1416 }
else if(text.empty() ==
false) {
1418 text_color, text, loc.x, loc.y
1447 const std::string& text,
1448 std::size_t font_size,
1453 if (text.empty())
return;
1459 renderer.set_maximum_height(-1,
false);
1460 renderer.set_foreground_color(color);
1465 dest.x - (res.w() / 2) + static_cast<int>(x_in_hex * dest.w),
1466 dest.y - (res.h() / 2) + static_cast<int>(y_in_hex * dest.h),
1479 image_path =
"misc/blank-hex.png~BLIT(" + image_path;
1493 if (submersion_amount > 0.0) {
1494 int submersion_line = image_height * (1.0 - submersion_amount);
1495 const std::string sl_string = std::to_string(submersion_line);
1496 image_path +=
"~ADJUST_ALPHA(if(y>";
1497 image_path += sl_string;
1498 image_path +=
",clamp((0.3-(y-";
1499 image_path += sl_string;
1500 image_path +=
")*0.015),0,1)*alpha,alpha))";
1509 image_path +=
",0,";
1510 image_path += std::to_string(shift);
1554 if(time_between_draws < 0) {
1560 using std::chrono::duration_cast;
1561 using std::chrono::seconds;
1562 using std::chrono::steady_clock;
1563 const seconds current_second = duration_cast<seconds>(steady_clock::now().time_since_epoch());
1576 if((*i)->pressed()) {
1592 if((*i)->pressed()) {
1607 if(
options.discard_previous) {
1655 ERR_DP <<
"trying to draw null minimap";
1688 double shift_x = -border *
hex_width() - (map_out_rect.w - map_rect.w) / 2;
1689 double shift_y = -(border + 0.25) *
hex_size() - (map_out_rect.h - map_rect.h) / 2;
1691 int view_x =
static_cast<int>((
xpos_ + shift_x) * xscaling);
1692 int view_y =
static_cast<int>((
ypos_ + shift_y) * yscaling);
1693 int view_w =
static_cast<int>(map_out_rect.w * xscaling);
1694 int view_h =
static_cast<int>(map_out_rect.h * yscaling);
1696 SDL_Rect outline_rect {
1713 for(
const auto& u :
dc_->
units()) {
1714 if (
fogged(u.get_location()) ||
1716 u.invisible(u.get_location())) ||
1721 int side = u.side();
1728 }
else if(
currentTeam_ + 1 ==
static_cast<unsigned>(side)) {
1736 double u_x = u.get_location().x * xscaling;
1737 double u_y = (u.get_location().y + (
is_odd(u.get_location().x) ? 1 : -1)/4.0) * yscaling;
1739 double u_w = 4.0 / 3.0 * xscaling;
1740 double u_h = yscaling;
1745 , int(std::round(u_w))
1746 , int(std::round(u_h))
1760 if(xmove == 0 && ymove == 0) {
1764 int new_x =
xpos_ + xmove;
1765 int new_y =
ypos_ + ymove;
1774 const int diff_x =
xpos_ - new_x;
1775 const int diff_y =
ypos_ - new_y;
1828 r.y = r.y + r.h + diff_y;
1831 r.h = std::abs(diff_y);
1839 r.x = r.x + r.w + diff_x;
1842 r.w = std::abs(diff_x);
1877 LOG_DP <<
"new_zoom = " << new_zoom;
1879 if(new_zoom ==
zoom_) {
1883 if(validate_value_and_set_index) {
1892 double zoom_factor =
static_cast<double>(new_zoom) /
static_cast<double>(
zoom_);
1906 xpos_ = std::round(((
xpos_ + area.w / 2) * zoom_factor) - (area.w / 2));
1907 ypos_ = std::round(((
ypos_ + area.h / 2) * zoom_factor) - (area.h / 2));
1951 return x + hs >= area.x - hw && x < area.x + area.w + hw &&
1952 y + hs >= area.y - hs && y < area.y + area.h + hs;
1962 const int xmove_expected = screenxpos - (area.x + area.w/2);
1963 const int ymove_expected = screenypos - (area.y + area.h/2);
1965 int xpos =
xpos_ + xmove_expected;
1966 int ypos =
ypos_ + ymove_expected;
1968 int xmove = xpos -
xpos_;
1969 int ymove = ypos -
ypos_;
1972 scroll(xmove,ymove,
true);
1983 const double dist_total = std::hypot(xmove, ymove);
1984 double dist_moved = 0.0;
1986 int t_prev = SDL_GetTicks();
1988 double velocity = 0.0;
1989 while (dist_moved < dist_total) {
1992 int t = SDL_GetTicks();
1993 double dt = (
t - t_prev) / 1000.0;
2005 double accel = velocity_max / accel_time;
2006 double decel = velocity_max / decel_time;
2009 double stop_time = velocity / decel;
2010 double dist_stop = dist_moved + velocity*stop_time - 0.5*decel*stop_time*stop_time;
2011 if (dist_stop > dist_total || velocity > velocity_max) {
2012 velocity -= decel * dt;
2013 if (velocity < 1.0) velocity = 1.0;
2015 velocity += accel * dt;
2016 if (velocity > velocity_max) velocity = velocity_max;
2019 dist_moved += velocity * dt;
2020 if (dist_moved > dist_total) dist_moved = dist_total;
2022 int x_new = std::round(xmove * dist_moved / dist_total);
2023 int y_new = std::round(ymove * dist_moved / dist_total);
2025 int dx = x_new - x_old;
2026 int dy = y_new - y_old;
2039 if(
get_map().on_board(loc) ==
false) {
2040 ERR_DP <<
"Tile at " << loc <<
" isn't on the map, can't scroll to the tile.";
2044 std::vector<map_location> locs;
2045 locs.push_back(loc);
2051 double add_spacing,
bool force)
2053 std::vector<map_location> locs;
2054 locs.push_back(loc1);
2055 locs.push_back(loc2);
2056 scroll_to_tiles(locs, scroll_type, check_fogged,
false, add_spacing,force);
2060 const std::vector<map_location>::const_iterator &
end,
2062 bool only_if_possible,
double add_spacing,
bool force)
2071 for(std::vector<map_location>::const_iterator itor =
begin; itor !=
end ; ++itor) {
2072 if(
get_map().on_board(*itor) ==
false)
continue;
2073 if(check_fogged &&
fogged(*itor))
continue;
2085 int minx_new = std::min<int>(minx,x);
2086 int miny_new = std::min<int>(miny,y);
2087 int maxx_new = std::max<int>(maxx,x);
2088 int maxy_new = std::max<int>(maxy,y);
2094 if (only_if_possible)
return;
2108 int spacing = std::round(add_spacing *
hex_size());
2122 locs_bbox.w = maxx - minx +
hex_size();
2123 locs_bbox.h = maxy - miny +
hex_size();
2126 int target_x = locs_bbox.x + locs_bbox.w/2;
2127 int target_y = locs_bbox.y + locs_bbox.h/2;
2132 int map_center_x = r.x + r.w/2;
2133 int map_center_y = r.y + r.h/2;
2139 double inside_frac = 0.5;
2140 w =
static_cast<int>(
w * inside_frac);
2141 h =
static_cast<int>(
h * inside_frac);
2151 r.x = target_x -
w/2;
2152 r.y = target_y -
h/2;
2160 if (map_center_x < r.x) {
2162 target_y = std::clamp(map_center_y, r.y, r.y + r.h - 1);
2163 }
else if (map_center_x > r.x+r.w-1) {
2164 target_x = r.x + r.w - 1;
2165 target_y = std::clamp(map_center_y, r.y, r.y + r.h - 1);
2166 }
else if (map_center_y < r.y) {
2168 target_x = std::clamp(map_center_x, r.x, r.x + r.w - 1);
2169 }
else if (map_center_y > r.y+r.h-1) {
2170 target_y = r.y + r.h - 1;
2171 target_x = std::clamp(map_center_x, r.x, r.x + r.w - 1);
2173 ERR_DP <<
"Bug in the scrolling code? Looks like we would not need to scroll after all...";
2196 xpos = std::clamp(xpos, 0, xend -
map_area().
w);
2197 ypos = std::clamp(ypos, 0, yend -
map_area().
h);
2203 if(
keys_[SDLK_LSHIFT] ||
keys_[SDLK_RSHIFT]) {
2215 const std::string& old_mask,
2216 const std::string& new_mask)
2223 int start = SDL_GetTicks();
2224 for(
int now =
start; now <
start + duration; now = SDL_GetTicks()) {
2225 float prop_f = float(now -
start) / float(duration);
2239 uint32_t
start = SDL_GetTicks();
2244 if(fade_start.a == 0) {
2245 fade_start.r = fade_end.r;
2246 fade_start.g = fade_end.g;
2247 fade_start.b = fade_end.b;
2251 if(fade_end.a == 0) {
2252 fade_end.r = fade_start.r;
2253 fade_end.g = fade_start.g;
2254 fade_end.b = fade_start.b;
2258 for(uint32_t now =
start; now <
start + duration; now = SDL_GetTicks()) {
2259 float prop_f = float(now -
start) / float(duration);
2280 DBG_DP <<
"redrawing everything";
2303 if(command_executor !=
nullptr) {
2347 DBG_DP <<
"display::draw denied";
2358 DBG_DP <<
"display::draw redraw background";
2411 DBG_DP <<
"draw() with invalidateAll";
2436 DBG_DP <<
"render prevented";
2452 ERR_DP <<
"error creating minimap";
2461 DBG_DP <<
"draw prevented";
2496 DBG_DP <<
"display::expose " << region;
2526 bool raw_size_changed =
size.x != oarea.w ||
size.y != oarea.h;
2527 bool draw_size_changed = dsize.x != darea.w || dsize.y != darea.h;
2528 if (!raw_size_changed && !draw_size_changed) {
2533 if(raw_size_changed) {
2534 LOG_DP <<
"regenerating render buffers as " << oarea;
2535 front_ =
texture(oarea.w, oarea.h, SDL_TEXTUREACCESS_TARGET);
2536 back_ =
texture(oarea.w, oarea.h, SDL_TEXTUREACCESS_TARGET);
2538 if(raw_size_changed || draw_size_changed) {
2539 LOG_DP <<
"updating render buffer draw size to " << darea;
2545 for(
int i = 0;
i < 2; ++
i) {
2562 for(
int i = 0;
i < 2; ++
i) {
2593 DBG_DP <<
"drawing " <<
invalidated_.size() <<
" invalidated hexes with clip " << clip_rect;
2596 std::optional<unit_drawer> drawer{};
2598 drawer.emplace(*
this);
2606 if(!hex_rect.
overlaps(clip_rect)) {
2618 drawer->redraw_unit(*u_it);
2633 int num_images_fg = 0;
2634 int num_images_bg = 0;
2678 std::vector<overlay>& overlays = it->second;
2679 if(overlays.size() != 0) {
2683 for(
const overlay& ov : overlays) {
2684 bool item_visible_for_team =
true;
2688 const std::vector<std::string>& current_team_names =
utils::split(current_team_name);
2689 const std::vector<std::string>& team_names =
utils::split(ov.team_name);
2691 item_visible_for_team = std::find_first_of(team_names.begin(), team_names.end(),
2692 current_team_names.begin(), current_team_names.end()) != team_names.end();
2695 if(item_visible_for_team && !(
fogged(loc) && !ov.visible_in_fog)) {
2697 std::string ipf = ov.image;
2701 double sub = submerge * ov.submerge;
2704 int shift = isize.y * (sub - submerge);
2708 const texture tex = ov.image.find(
"~NO_TOD_SHIFT()") == std::string::npos
2726 const std::string& tod_hex_mask = tod.
image_mask;
2735 }
else if(!tod_hex_mask.empty()) {
2741 arrows_map_t::const_iterator arrows_in_hex =
arrows_map_.find(loc);
2743 for (
arrow*
const a : arrows_in_hex->second) {
2788 std::ostringstream ss;
2798 ss << (num_images_bg + num_images_fg) <<
'\n';
2801 std::string
output = ss.str();
2811 renderer.set_alignment(PANGO_ALIGN_CENTER);
2813 renderer.set_maximum_height(-1,
false);
2817 const rect text_dest {
2818 (dest.x + dest.w / 2) - (tex.w() / 2),
2819 (dest.y + dest.h / 2) - (tex.h() / 2),
2825 const rect bg_dest {
2864 if ( new_cfg ==
nullptr )
2865 new_cfg = &generated_cfg;
2872 if (loc == new_loc && report == *new_cfg) {
2876 DBG_DP <<
"updating report: " << report_name;
2890 if (report.
empty())
return;
2895 std::string str =
item->prefix();
2901 str =
item->postfix();
2926 int x = loc.x, y = loc.y;
2930 int image_count = 0;
2931 bool used_ellipsis =
false;
2932 std::ostringstream ellipsis_tooltip;
2933 SDL_Rect ellipsis_area = loc;
2936 elements.begin() != elements.end(); elements.pop_front())
2938 SDL_Rect area {x, y, loc.w + loc.x - x, loc.h + loc.y - y};
2939 if (area.h <= 0)
break;
2941 std::string
t = elements.front()[
"text"];
2944 if (used_ellipsis)
goto skip_element;
2949 if (
t[
t.size() - 1] ==
'\n') {
2951 t =
t.substr(0,
t.size() - 1);
2975 const int minimal_text = 12;
2977 if (!eol && loc.w - (x - loc.x + tsize.x) < minimal_text &&
2978 ++ee != elements.end() && !(*ee)[
"text"].empty())
2987 used_ellipsis =
true;
2988 ellipsis_area.x = x;
2989 ellipsis_area.y = y;
2990 ellipsis_area.w = tsize.x;
2991 ellipsis_area.h = tsize.y;
2996 if (!tooltip_test) {
2999 if (area.h > tallest) {
3010 else if (!(
t = elements.front()[
"image"].str()).empty())
3012 if (used_ellipsis)
goto skip_element;
3018 ERR_DP <<
"could not find image for report: '" <<
t <<
"'";
3022 if (area.w < img.
w() && image_count) {
3025 used_ellipsis =
true;
3028 if (img.
w() < area.w) area.w = img.
w();
3029 if (img.
h() < area.h) area.h = img.
h();
3030 if (!tooltip_test) {
3035 if (area.h > tallest) {
3039 if (!used_ellipsis) {
3042 ellipsis_area = area;
3052 t = elements.front()[
"tooltip"].t_str().c_str();
3054 if (tooltip_test && !used_ellipsis) {
3060 ellipsis_tooltip <<
t;
3062 if (++ee != elements.end())
3063 ellipsis_tooltip <<
"\n _________\n\n";
3068 if (tooltip_test && used_ellipsis) {
3077 const std::string& name = it.first;
3089 DBG_DP <<
"invalidate_all()";
3123 bool result =
false;
3126 std::set<map_location>::const_iterator
i = locs.begin();
3129 if (
i != locs.end()) {
3152 DBG_DP <<
"invalidating locations in " <<
rect;
3154 bool result =
false;
3164 if(
get_map().is_village(loc)) {
3166 if(owner >= 0 &&
flags_[owner].need_update()
3182 if(
builder_->update_animation(loc)) {
3191 u.anim_comp().refresh();
3194 u->anim_comp().refresh();
3201 new_inval |= u.anim_comp().invalidate(*
this);
3204 new_inval |= u->anim_comp().invalidate(*
this);
3214 u.anim_comp().set_standing();
3275 if (reach == full.end()) {
3278 }
else if (reach->second != 1) {
3291 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.
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.
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()
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)
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.
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
std::string shroud_prefix
const color_range & color_info(const std::string &name)
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.
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.
surface getMinimap(int w, int h, const gamemap &map, const team *vw, const std::map< map_location, unsigned int > *reach_map, bool ignore_terrain_disabled)
function to create the minimap for a given map the surface returned must be freed by the user
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