0ct0pu5/wesnoth
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Display: formatting, minor code cleanup

Browse source
This commit is contained in:
Charles Dang 2022-04-01 02:23:28 -04:00
parent 0f8ffad0cd
commit 2f3927733d
1 changed files with 159 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

325
src/display.cpp
View file

@ -398,19 +398,17 @@ void display::set_team(std::size_t teamindex, bool show_everything)
{
assert(teamindex < dc_->teams().size());
currentTeam_ = teamindex;
if (!show_everything)
{
if(!show_everything) {
labels().set_team(&dc_->teams()[teamindex]);
dont_show_all_ = true;
}
else
{
} else {
labels().set_team(nullptr);
dont_show_all_ = false;
}
labels().recalculate_labels();
if(std::shared_ptr<wb::manager> w = wb_.lock())
if(std::shared_ptr<wb::manager> w = wb_.lock()) {
w->on_viewer_change(teamindex);
}
}
void display::set_playing_team(std::size_t teamindex)
@ -422,13 +420,10 @@ void display::set_playing_team(std::size_t teamindex)
bool display::add_exclusive_draw(const map_location& loc, unit& unit)
{
if (loc.valid() && exclusive_unit_draw_requests_.find(loc) == exclusive_unit_draw_requests_.end())
{
if(loc.valid() && exclusive_unit_draw_requests_.find(loc) == exclusive_unit_draw_requests_.end()) {
exclusive_unit_draw_requests_[loc] = unit.id();
return true;
}
else
{
} else {
return false;
}
}
@ -536,10 +531,9 @@ bool display::is_blindfolded() const
return blindfold_ctr_ > 0;
}
const SDL_Rect& display::max_map_area() const
{
static SDL_Rect max_area {0, 0, 0, 0};
static SDL_Rect max_area{0, 0, 0, 0};
// hex_size() is always a multiple of 4
// and hex_width() a multiple of 3,
@ -548,7 +542,7 @@ const SDL_Rect& display::max_map_area() const
// To display a hex fully on screen,
// a little bit extra space is needed.
// Also added the border two times.
max_area.w = static_cast<int>((get_map().w() + 2 * theme_.border().size + 1.0/3.0) * hex_width());
max_area.w = static_cast<int>((get_map().w() + 2 * theme_.border().size + 1.0 / 3.0) * hex_width());
max_area.h = static_cast<int>((get_map().h() + 2 * theme_.border().size + 0.5) * hex_size());
return max_area;
@ -560,7 +554,7 @@ const SDL_Rect& display::map_area() const
max_area = max_map_area();
// if it's for map_screenshot, maximize and don't recenter
if (map_screenshot_) {
if(map_screenshot_) {
return max_area;
}
@ -569,13 +563,13 @@ const SDL_Rect& display::map_area() const
if(max_area.w < res.w) {
// map is smaller, center
res.x += (res.w - max_area.w)/2;
res.x += (res.w - max_area.w) / 2;
res.w = max_area.w;
}
if(max_area.h < res.h) {
// map is smaller, center
res.y += (res.h - max_area.h)/2;
res.y += (res.h - max_area.h) / 2;
res.h = max_area.h;
}
@ -586,8 +580,7 @@ bool display::outside_area(const SDL_Rect& area, const int x, const int y)
{
const int x_thresh = hex_size();
const int y_thresh = hex_size();
return (x < area.x || x > area.x + area.w - x_thresh ||
y < area.y || y > area.y + area.h - y_thresh);
return (x < area.x || x > area.x + area.w - x_thresh || y < area.y || y > area.y + area.h - y_thresh);
}
// This function uses the screen as reference
@ -604,7 +597,6 @@ const map_location display::hex_clicked_on(int xclick, int yclick) const
return pixel_position_to_hex(xpos_ + xclick, ypos_ + yclick);
}
// This function uses the rect of map_area as reference
const map_location display::pixel_position_to_hex(int x, int y) const
{
@ -684,7 +676,7 @@ const display::rect_of_hexes display::hexes_under_rect(const SDL_Rect& r) const
{
rect_of_hexes res;
if (r.w<=0 || r.h<=0) {
if(r.w <= 0 || r.h <= 0) {
// empty rect, return dummy values giving begin=end
res.left = 0;
res.right = -1; // end is right+1
@ -711,14 +703,14 @@ const display::rect_of_hexes display::hexes_under_rect(const SDL_Rect& r) const
res.left = static_cast<int>(std::floor(-border + x / tile_width - 0.3333333));
// we remove 1 pixel of the rectangle dimensions
// (the rounded division take one pixel more than needed)
res.right = static_cast<int>(std::floor(-border + (x + r.w-1) / tile_width));
res.right = static_cast<int>(std::floor(-border + (x + r.w - 1) / tile_width));
// for odd x, we must shift up one half-hex. Since x will vary along the edge,
// we store here the y values for even and odd x, respectively
res.top[0] = static_cast<int>(std::floor(-border + y / tile_size));
res.top[1] = static_cast<int>(std::floor(-border + y / tile_size - 0.5));
res.bottom[0] = static_cast<int>(std::floor(-border + (y + r.h-1) / tile_size));
res.bottom[1] = static_cast<int>(std::floor(-border + (y + r.h-1) / tile_size - 0.5));
res.bottom[0] = static_cast<int>(std::floor(-border + (y + r.h - 1) / tile_size));
res.bottom[1] = static_cast<int>(std::floor(-border + (y + r.h - 1) / tile_size - 0.5));
// TODO: in some rare cases (1/16), a corner of the big rect is on a tile
// (the 72x72 rectangle containing the hex) but not on the hex itself
@ -754,10 +746,10 @@ int display::get_location_y(const map_location& loc) const
map_location display::minimap_location_on(int x, int y)
{
//TODO: don't return location for this,
// TODO: don't return location for this,
// instead directly scroll to the clicked pixel position
if (!sdl::point_in_rect(x, y, minimap_area())) {
if(!sdl::point_in_rect(x, y, minimap_area())) {
return map_location();
}
@ -765,19 +757,21 @@ map_location display::minimap_location_on(int x, int y)
// probably more adjustments to do (border, minimap shift...)
// but the mouse and human capacity to evaluate the rectangle center
// is not pixel precise.
int px = (x - minimap_location_.x) * get_map().w()*hex_width() / std::max (minimap_location_.w, 1);
int py = (y - minimap_location_.y) * get_map().h()*hex_size() / std::max(minimap_location_.h, 1);
int px = (x - minimap_location_.x) * get_map().w() * hex_width() / std::max(minimap_location_.w, 1);
int py = (y - minimap_location_.y) * get_map().h() * hex_size() / std::max(minimap_location_.h, 1);
map_location loc = pixel_position_to_hex(px, py);
if (loc.x < 0)
if(loc.x < 0) {
loc.x = 0;
else if (loc.x >= get_map().w())
} else if(loc.x >= get_map().w()) {
loc.x = get_map().w() - 1;
}
if (loc.y < 0)
if(loc.y < 0) {
loc.y = 0;
else if (loc.y >= get_map().h())
} else if(loc.y >= get_map().h()) {
loc.y = get_map().h() - 1;
}
return loc;
}
@ -826,9 +820,9 @@ surface display::screenshot(bool map_screenshot)
std::shared_ptr<gui::button> display::find_action_button(const std::string& id)
{
for (std::size_t i = 0; i < action_buttons_.size(); ++i) {
if(action_buttons_[i]->id() == id) {
return action_buttons_[i];
for(auto& b : action_buttons_) {
if(b->id() == id) {
return b;
}
}
return nullptr;
@ -836,9 +830,9 @@ std::shared_ptr<gui::button> display::find_action_button(const std::string& id)
std::shared_ptr<gui::button> display::find_menu_button(const std::string& id)
{
for (std::size_t i = 0; i < menu_buttons_.size(); ++i) {
if(menu_buttons_[i]->id() == id) {
return menu_buttons_[i];
for(auto& b : menu_buttons_) {
if(b->id() == id) {
return b;
}
}
return nullptr;
@ -848,8 +842,7 @@ void display::layout_buttons()
{
DBG_DP << "positioning menu buttons...\n";
for(const auto& menu : theme_.menus()) {
std::shared_ptr<gui::button> b = find_menu_button(menu.get_id());
if(b) {
if(auto b = find_menu_button(menu.get_id())) {
const SDL_Rect& loc = menu.location(screen_.screen_area());
b->set_location(loc);
b->set_measurements(0,0);
@ -860,8 +853,7 @@ void display::layout_buttons()
DBG_DP << "positioning action buttons...\n";
for(const auto& action : theme_.actions()) {
std::shared_ptr<gui::button> b = find_action_button(action.get_id());
if(b) {
if(auto b = find_action_button(action.get_id())) {
const SDL_Rect& loc = action.location(screen_.screen_area());
b->set_location(loc);
b->set_measurements(0,0);
@ -898,71 +890,66 @@ const std::string& get_direction(std::size_t n)
void display::create_buttons()
{
std::vector<std::shared_ptr<gui::button>> menu_work;
std::vector<std::shared_ptr<gui::button>> action_work;
menu_buttons_.clear();
action_buttons_.clear();
DBG_DP << "creating menu buttons...\n";
for(const auto& menu : theme_.menus()) {
if (!menu.is_button()) continue;
if(!menu.is_button()) {
continue;
}
auto b = std::make_shared<gui::button>(screen_, menu.title(), gui::button::TYPE_PRESS, menu.image(),
gui::button::DEFAULT_SPACE, false, menu.overlay(), font::SIZE_BUTTON_SMALL);
std::shared_ptr<gui::button> b(new gui::button(screen_, menu.title(), gui::button::TYPE_PRESS, menu.image(),
gui::button::DEFAULT_SPACE, false, menu.overlay(), font::SIZE_BUTTON_SMALL));
DBG_DP << "drawing button " << menu.get_id() << "\n";
b->join_same(this);
b->set_id(menu.get_id());
if (!menu.tooltip().empty()){
if(!menu.tooltip().empty()) {
b->set_tooltip_string(menu.tooltip());
}
std::shared_ptr<gui::button> b_prev = find_menu_button(b->id());
if(b_prev) {
if(auto b_prev = find_menu_button(b->id())) {
b->enable(b_prev->enabled());
}
menu_work.push_back(b);
menu_buttons_.push_back(std::move(b));
}
DBG_DP << "creating action buttons...\n";
for(const auto& action : theme_.actions()) {
std::shared_ptr<gui::button> b(new gui::button(screen_, action.title(), string_to_button_type(action.type()), action.image(),
gui::button::DEFAULT_SPACE, false, action.overlay(), font::SIZE_BUTTON_SMALL));
auto b = std::make_shared<gui::button>(screen_, action.title(), string_to_button_type(action.type()),
action.image(), gui::button::DEFAULT_SPACE, false, action.overlay(), font::SIZE_BUTTON_SMALL);
DBG_DP << "drawing button " << action.get_id() << "\n";
b->set_id(action.get_id());
b->join_same(this);
if (!action.tooltip(0).empty()){
if(!action.tooltip(0).empty()) {
b->set_tooltip_string(action.tooltip(0));
}
std::shared_ptr<gui::button> b_prev = find_action_button(b->id());
if(b_prev) {
if(auto b_prev = find_action_button(b->id())) {
b->enable(b_prev->enabled());
if (b_prev->get_type() == gui::button::TYPE_CHECK) {
if(b_prev->get_type() == gui::button::TYPE_CHECK) {
b->set_check(b_prev->checked());
}
}
action_work.push_back(b);
action_buttons_.push_back(std::move(b));
}
menu_buttons_.clear();
menu_buttons_.assign(menu_work.begin(), menu_work.end());
action_buttons_.clear();
action_buttons_.assign(action_work.begin(), action_work.end());
layout_buttons();
DBG_DP << "buttons created\n";
}
void display::render_buttons()
{
for (std::shared_ptr<gui::button> btn : menu_buttons_) {
for(auto& btn : menu_buttons_) {
btn->set_dirty(true);
btn->draw();
}
for (std::shared_ptr<gui::button> btn : action_buttons_) {
for(auto& btn : action_buttons_) {
btn->set_dirty(true);
btn->draw();
}
@ -973,11 +960,10 @@ std::vector<surface> display::get_fog_shroud_images(const map_location& loc, ima
std::vector<std::string> names;
const auto adjacent = get_adjacent_tiles(loc);
enum visibility {FOG=0, SHROUD=1, CLEAR=2};
visibility tiles[6];
enum visibility { FOG = 0, SHROUD = 1, CLEAR = 2 };
std::array<visibility, 6> tiles;
const std::string* image_prefix[] =
{ &game_config::fog_prefix, &game_config::shroud_prefix};
const std::array image_prefix{&game_config::fog_prefix, &game_config::shroud_prefix};
for(int i = 0; i < 6; ++i) {
if(shrouded(adjacent[i])) {
@ -1002,7 +988,7 @@ std::vector<surface> display::get_fog_shroud_images(const map_location& loc, ima
// Completely surrounded by fog or shroud. This might have
// a special graphic.
const std::string name = *image_prefix[v] + "-all.png";
if ( image::exists(name) ) {
if(image::exists(name)) {
names.push_back(name);
// Proceed to the next visibility (fog -> shroud -> clear).
continue;
@ -1013,20 +999,20 @@ std::vector<surface> display::get_fog_shroud_images(const map_location& loc, ima
}
// Find all the directions overlap occurs from
for (int i = (start+1)%6, cap1 = 0; i != start && cap1 != 6; ++cap1) {
for(int i = (start + 1) % 6, cap1 = 0; i != start && cap1 != 6; ++cap1) {
if(tiles[i] == v) {
std::ostringstream stream;
std::string name;
stream << *image_prefix[v];
for (int cap2 = 0; v == tiles[i] && cap2 != 6; i = (i+1)%6, ++cap2) {
for(int cap2 = 0; v == tiles[i] && cap2 != 6; i = (i + 1) % 6, ++cap2) {
stream << get_direction(i);
if(!image::exists(stream.str() + ".png")) {
// If we don't have any surface at all,
// then move onto the next overlapped area
if(name.empty()) {
i = (i+1)%6;
i = (i + 1) % 6;
}
break;
} else {
@ -1038,7 +1024,7 @@ std::vector<surface> display::get_fog_shroud_images(const map_location& loc, ima
names.push_back(name + ".png");
}
} else {
i = (i+1)%6;
i = (i + 1) % 6;
}
}
}
@ -1046,40 +1032,31 @@ std::vector<surface> display::get_fog_shroud_images(const map_location& loc, ima
// now get the surfaces
std::vector<surface> res;
for (std::string& name : names) {
surface surf(image::get_image(name, image_type));
if (surf)
for(const std::string& name : names) {
if(surface surf = image::get_image(name, image_type)) {
res.push_back(std::move(surf));
}
}
return res;
}
void display::get_terrain_images(const map_location &loc,
const std::string& timeid,
TERRAIN_TYPE terrain_type)
void display::get_terrain_images(const map_location& loc, const std::string& timeid, TERRAIN_TYPE terrain_type)
{
terrain_image_vector_.clear();
terrain_builder::TERRAIN_TYPE builder_terrain_type =
(terrain_type == FOREGROUND ?
terrain_builder::FOREGROUND : terrain_builder::BACKGROUND);
const terrain_builder::imagelist* const terrains = builder_->get_terrain_at(loc,
timeid, builder_terrain_type);
image::light_string lt;
const time_of_day& tod = get_time_of_day(loc);
//get all the light transitions
// get all the light transitions
const auto adjs = get_adjacent_tiles(loc);
std::array<const time_of_day*, 6> atods;
for(size_t d = 0; d < adjs.size(); ++d){
std::array<const time_of_day*, adjs.size()> atods;
for(std::size_t d = 0; d < adjs.size(); ++d) {
atods[d] = &get_time_of_day(adjs[d]);
}
for(int d=0; d<6; ++d){
for(int d = 0; d < 6; ++d) {
/*
concave
_____
@ -1096,11 +1073,12 @@ void display::get_terrain_images(const map_location &loc,
const time_of_day& atod1 = *atods[d];
const time_of_day& atod2 = *atods[(d + 1) % 6];
if(atod1.color == tod.color || atod2.color == tod.color || atod1.color != atod2.color)
if(atod1.color == tod.color || atod2.color == tod.color || atod1.color != atod2.color) {
continue;
}
if(lt.empty()) {
//color the full hex before adding transitions
// color the full hex before adding transitions
tod_color col = tod.color + color_adjust_;
lt = image::get_light_string(0, col.r, col.g, col.b);
}
@ -1109,7 +1087,8 @@ void display::get_terrain_images(const map_location &loc,
tod_color acol = atod1.color + color_adjust_;
lt += image::get_light_string(d + 1, acol.r, acol.g, acol.b);
}
for(int d=0; d<6; ++d){
for(int d = 0; d < 6; ++d) {
/*
convex 1
_____
@ -1126,11 +1105,12 @@ void display::get_terrain_images(const map_location &loc,
const time_of_day& atod1 = *atods[d];
const time_of_day& atod2 = *atods[(d + 1) % 6];
if(atod1.color == tod.color || atod1.color == atod2.color)
if(atod1.color == tod.color || atod1.color == atod2.color) {
continue;
}
if(lt.empty()) {
//color the full hex before adding transitions
// color the full hex before adding transitions
tod_color col = tod.color + color_adjust_;
lt = image::get_light_string(0, col.r, col.g, col.b);
}
@ -1139,7 +1119,8 @@ void display::get_terrain_images(const map_location &loc,
tod_color acol = atod1.color + color_adjust_;
lt += image::get_light_string(d + 7, acol.r, acol.g, acol.b);
}
for(int d=0; d<6; ++d){
for(int d = 0; d < 6; ++d) {
/*
convex 2
_____
@ -1156,11 +1137,12 @@ void display::get_terrain_images(const map_location &loc,
const time_of_day& atod1 = *atods[d];
const time_of_day& atod2 = *atods[(d + 1) % 6];
if(atod2.color == tod.color || atod1.color == atod2.color)
if(atod2.color == tod.color || atod1.color == atod2.color) {
continue;
}
if(lt.empty()) {
//color the full hex before adding transitions
// color the full hex before adding transitions
tod_color col = tod.color + color_adjust_;
lt = image::get_light_string(0, col.r, col.g, col.b);
}
@ -1178,21 +1160,23 @@ void display::get_terrain_images(const map_location &loc,
}
}
if(terrains != nullptr) {
// Cache the offmap name.
// Since it is themeable it can change,
// so don't make it static.
const terrain_builder::TERRAIN_TYPE builder_terrain_type = terrain_type == FOREGROUND
? terrain_builder::FOREGROUND
: terrain_builder::BACKGROUND;
if(const terrain_builder::imagelist* const terrains = builder_->get_terrain_at(loc, timeid, builder_terrain_type)) {
// Cache the offmap name. Since it is themeable it can change, so don't make it static.
const std::string off_map_name = "terrain/" + theme_.border().tile_image;
for(const auto& terrain : *terrains) {
const image::locator &image = animate_map_ ?
terrain.get_current_frame() : terrain.get_first_frame();
const image::locator& image = animate_map_ ? terrain.get_current_frame() : terrain.get_first_frame();
// We prevent ToD coloring and brightening of off-map tiles,
// We need to test for the tile to be rendered and
// not the location, since the transitions are rendered
// over the offmap-terrain and these need a ToD coloring.
surface surf;
const bool off_map = (image.get_filename() == off_map_name || image.get_modifications().find("NO_TOD_SHIFT()") != std::string::npos);
const bool off_map = (image.get_filename() == off_map_name
|| image.get_modifications().find("NO_TOD_SHIFT()") != std::string::npos);
if(off_map) {
surf = image::get_image(image, image::SCALED_TO_HEX);
@ -1202,7 +1186,7 @@ void display::get_terrain_images(const map_location &loc,
surf = image::get_lighted_image(image, lt, image::SCALED_TO_HEX);
}
if (surf) {
if(surf) {
terrain_image_vector_.push_back(std::move(surf));
}
}
@ -1298,17 +1282,16 @@ void display::drawing_buffer_commit()
* layergroup > location > layer > 'blit_helper' > surface
*/
for (const blit_helper &blit : drawing_buffer_) {
for (const surface& surf : blit.surf()) {
for(const blit_helper& blit : drawing_buffer_) {
for(const surface& surf : blit.surf()) {
// Note that dstrect can be changed by sdl_blit
// and so a new instance should be initialized
// to pass to each call to sdl_blit.
SDL_Rect dstrect {blit.x(), blit.y(), 0, 0};
SDL_Rect dstrect{blit.x(), blit.y(), 0, 0};
SDL_Rect srcrect = blit.clip();
SDL_Rect *srcrectArg = (srcrect.x | srcrect.y | srcrect.w | srcrect.h)
? &srcrect : nullptr;
SDL_Rect* srcrectArg = (srcrect.x | srcrect.y | srcrect.w | srcrect.h) ? &srcrect : nullptr;
sdl_blit(surf, srcrectArg, screen, &dstrect);
//NOTE: the screen part should already be marked as 'to update'
// NOTE: the screen part should already be marked as 'to update'
}
}
drawing_buffer_clear();
@ -1756,8 +1739,8 @@ void display::announce(const std::string& message, const color_t& color, const a
font::floating_label flabel(message);
flabel.set_font_size(font::SIZE_FLOAT_LABEL);
flabel.set_color(color);
flabel.set_position(map_outside_area().x + map_outside_area().w/2,
map_outside_area().y + map_outside_area().h/3);
flabel.set_position(
map_outside_area().x + map_outside_area().w / 2, map_outside_area().y + map_outside_area().h / 3);
flabel.set_lifetime(options.lifetime);
flabel.set_clip_rect(map_outside_area());
@ -1806,8 +1789,8 @@ void display::draw_minimap()
SDL_Rect map_rect = map_area();
SDL_Rect map_out_rect = map_outside_area();
double border = theme_.border().size;
double shift_x = - border*hex_width() - (map_out_rect.w - map_rect.w) / 2;
double shift_y = - (border+0.25)*hex_size() - (map_out_rect.h - map_rect.h) / 2;
double shift_x = -border * hex_width() - (map_out_rect.w - map_rect.w) / 2;
double shift_y = -(border + 0.25) * hex_size() - (map_out_rect.h - map_rect.h) / 2;
int view_x = static_cast<int>((xpos_ + shift_x) * xscaling);
int view_y = static_cast<int>((ypos_ + shift_y) * yscaling);
@ -2376,7 +2359,7 @@ double display::turbo_speed() const
}
res |= screen_.faked();
if (res)
if(res)
return preferences::turbo_speed();
else
return 1.0;
@ -2441,23 +2424,25 @@ void display::clear_redraw_observers()
redraw_observers_.clear();
}
void display::draw() {
void display::draw()
{
draw(true, false);
}
void display::draw(bool update) {
void display::draw(bool update)
{
draw(update, false);
}
void display::draw(bool update, bool force)
{
// log_scope("display::draw");
void display::draw(bool update,bool force) {
// log_scope("display::draw");
if (screen_.update_locked()) {
if(screen_.update_locked()) {
return;
}
if (dirty_) {
if(dirty_) {
flip_locker flip_lock(screen_);
dirty_ = false;
redraw_everything();
@ -2465,7 +2450,7 @@ void display::draw(bool update,bool force) {
}
// Trigger cache rebuild when preference gets changed
if (animate_water_ != preferences::animate_water()) {
if(animate_water_ != preferences::animate_water()) {
animate_water_ = preferences::animate_water();
builder_->rebuild_cache_all();
}
@ -2478,8 +2463,6 @@ void display::draw(bool update,bool force) {
invalidate_animations();
if(!get_map().empty()) {
//int simulate_delay = 0;
/*
* draw_invalidated() also invalidates the halos, so also needs to be
* ran if invalidated_.empty() == true.
@ -2491,9 +2474,6 @@ void display::draw(bool update,bool force) {
drawing_buffer_commit();
post_commit();
draw_sidebar();
// Simulate slow PC:
//SDL_Delay(2*simulate_delay + rand() % 20);
}
draw_wrap(update, force);
post_draw();
@ -2533,25 +2513,25 @@ void display::draw_invalidated() {
}
invalidated_hexes_ += invalidated_.size();
if (dc_->teams().empty())
{
// The unit drawer can't function without teams
if(dc_->teams().empty()) {
return;
}
unit_drawer drawer = unit_drawer(*this);
for (const map_location& loc : invalidated_) {
for(const map_location& loc : invalidated_) {
unit_map::const_iterator u_it = dc_->units().find(loc);
exclusive_unit_draw_requests_t::iterator request = exclusive_unit_draw_requests_.find(loc);
if (u_it != dc_->units().end()
&& (request == exclusive_unit_draw_requests_.end() || request->second == u_it->id()))
if(u_it != dc_->units().end()
&& (request == exclusive_unit_draw_requests_.end() || request->second == u_it->id())) {
drawer.redraw_unit(*u_it);
}
}
}
void display::draw_hex(const map_location& loc) {
void display::draw_hex(const map_location& loc)
{
int xpos = get_location_x(loc);
int ypos = get_location_y(loc);
image::TYPE image_type = get_image_type(loc);
@ -3039,7 +3019,7 @@ bool display::propagate_invalidation(const std::set<map_location>& locs)
bool display::invalidate_visible_locations_in_rect(const SDL_Rect& rect)
{
return invalidate_locations_in_rect(sdl::intersect_rects(map_area(),rect));
return invalidate_locations_in_rect(sdl::intersect_rects(map_area(), rect));
}
bool display::invalidate_locations_in_rect(const SDL_Rect& rect)
@ -3048,17 +3028,18 @@ bool display::invalidate_locations_in_rect(const SDL_Rect& rect)
return false;
bool result = false;
for (const map_location &loc : hexes_under_rect(rect)) {
for(const map_location& loc : hexes_under_rect(rect)) {
result |= invalidate(loc);
}
return result;
}
void display::invalidate_animations_location(const map_location& loc) {
if (get_map().is_village(loc)) {
void display::invalidate_animations_location(const map_location& loc)
{
if(get_map().is_village(loc)) {
const int owner = dc_->village_owner(loc) - 1;
if (owner >= 0 && flags_[owner].need_update()
&& (!fogged(loc) || !dc_->teams()[currentTeam_].is_enemy(owner+1))) {
if(owner >= 0 && flags_[owner].need_update()
&& (!fogged(loc) || !dc_->teams()[currentTeam_].is_enemy(owner + 1))) {
invalidate(loc);
}
}
@ -3068,11 +3049,11 @@ void display::invalidate_animations()
{
new_animation_frame();
animate_map_ = preferences::animate_map();
if (animate_map_) {
for (const map_location &loc : get_visible_hexes())
{
if (shrouded(loc)) continue;
if (builder_->update_animation(loc)) {
if(animate_map_) {
for(const map_location& loc : get_visible_hexes()) {
if(shrouded(loc))
continue;
if(builder_->update_animation(loc)) {
invalidate(loc);
} else {
invalidate_animations_location(loc);
@ -3083,21 +3064,20 @@ void display::invalidate_animations()
for(const unit& u : dc_->units()) {
u.anim_comp().refresh();
}
for (const unit* u : *fake_unit_man_) {
for(const unit* u : *fake_unit_man_) {
u->anim_comp().refresh();
}
bool new_inval;
do {
new_inval = false;
for (const unit & u : dc_->units()) {
for(const unit& u : dc_->units()) {
new_inval |= u.anim_comp().invalidate(*this);
}
for (const unit* u : *fake_unit_man_) {
for(const unit* u : *fake_unit_man_) {
new_inval |= u->anim_comp().invalidate(*this);
}
} while (new_inval);
} while(new_inval);
}
void display::reset_standing_animations()
@ -3109,32 +3089,25 @@ void display::reset_standing_animations()
void display::add_arrow(arrow& arrow)
{
const arrow_path_t & arrow_path = arrow.get_path();
for (const map_location& loc : arrow_path)
{
for(const map_location& loc : arrow.get_path()) {
arrows_map_[loc].push_back(&arrow);
}
}
void display::remove_arrow(arrow& arrow)
{
const arrow_path_t & arrow_path = arrow.get_path();
for (const map_location& loc : arrow_path)
{
for(const map_location& loc : arrow.get_path()) {
arrows_map_[loc].remove(&arrow);
}
}
void display::update_arrow(arrow & arrow)
{
const arrow_path_t & previous_path = arrow.get_previous_path();
for (const map_location& loc : previous_path)
{
for(const map_location& loc : arrow.get_previous_path()) {
arrows_map_[loc].remove(&arrow);
}
const arrow_path_t & arrow_path = arrow.get_path();
for (const map_location& loc : arrow_path)
{
for(const map_location& loc : arrow.get_path()) {
arrows_map_[loc].push_back(&arrow);
}
}
@ -3201,9 +3174,10 @@ void display::process_reachmap_changes()
reach_map_changed_ = false;
}
void display::handle_window_event(const SDL_Event& event) {
if (event.type == SDL_WINDOWEVENT) {
switch (event.window.event) {
void display::handle_window_event(const SDL_Event& event)
{
if(event.type == SDL_WINDOWEVENT) {
switch(event.window.event) {
case SDL_WINDOWEVENT_RESIZED:
case SDL_WINDOWEVENT_RESTORED:
case SDL_WINDOWEVENT_EXPOSED:
@ -3212,15 +3186,14 @@ void display::handle_window_event(const SDL_Event& event) {
break;
}
}
}
void display::handle_event(const SDL_Event& event) {
if (gui2::dialogs::loading_screen::displaying()) {
void display::handle_event(const SDL_Event& event)
{
if(gui2::dialogs::loading_screen::displaying()) {
return;
}
if (event.type == DRAW_ALL_EVENT) {
if(event.type == DRAW_ALL_EVENT) {
draw();
}
}