// Complexity: O(nr lg(nr) + nr^2), where n = locs.size(), r = radius.
// The nr^2 term is bounded by the size of the board.
void get_tiles_radius(const gamemap& map, const std::vector<map_location>& locs,
size_t radius, std::set<map_location>& result,
bool with_border)
{
// Make sure the provided locations are included.
// This would be needed in case some of the provided locations are off-map.
// It also allows simpler processing if the radius is zero.
// For efficiency, do this first since locs is potentially unsorted.
result.insert(locs.begin(), locs.end());
if ( radius != 0 && !locs.empty() )
{
const int border = with_border ? map.border_size() : 0;
column_ranges collected_tiles;
// Collect the hexes within the desired disks into collected_tiles.
// This maps each x-value to a set of ranges of y-values that
// are covered by the disks around each element of locs.
// (So the data size at this point is proportional to the number
// of x-values involved, which is O(nr). The lg(nr) factor comes
// from the data being sorted.)
get_column_ranges(collected_tiles, locs, radius, -border, map.w() + border);
// Now that all the tiles have been collected, add them to result.
// (There are O(nr^2) hexes to add.) By collecting before adding, each
// hex will be processed only once, even when disks overlap. This is
// how we can get good performance if there is significant overlap, and
// how the work required can be bound by the size of the board.
ranges_to_tiles(result, collected_tiles, -border, map.h() + border);
}
}
bool move_result::test_route(const unit &un, const team &my_team, const unit_map &units, const std::vector<team> &teams, const gamemap &map, bool)
{
if (from_== to_) {
if (!remove_movement_ || (un.movement_left() == 0) ) {
set_error(E_EMPTY_MOVE);
return false;
}
return true;
}
if (un.movement_left() == 0 ) {
set_error(E_EMPTY_MOVE);
return false;
}
if (!to_.valid()) {
set_error(E_NO_ROUTE);
return false;
}
const pathfind::shortest_path_calculator calc(un, my_team, units, teams,map);
//allowed teleports
std::set<map_location> allowed_teleports = pathfind::get_teleport_locations(un, units, my_team, true);//@todo 1.9: see_all -> false
//do an A*-search
route_ = pathfind::a_star_search(un.get_location(), to_, 10000.0, &calc, map.w(), map.h(), &allowed_teleports);
if (route_.steps.empty()) {
set_error(E_NO_ROUTE);
return false;
}
return true;
}
gamemap editor_map::mask_to(const gamemap& target) const
{
if (target.w() != w() || target.h() != h()) {
throw editor_action_exception(_("The size of the target map is different from the current map"));
}
gamemap mask(target);
map_location iter;
for (iter.x = -border_size(); iter.x < w() + border_size(); ++iter.x) {
for (iter.y = -border_size(); iter.y < h() + border_size(); ++iter.y) {
if (target.get_terrain(iter) == get_terrain(iter)) {
mask.set_terrain(iter, t_translation::FOGGED);
}
}
}
return mask;
}
static void find_routes(const gamemap& map, const unit_map& units,
const unit& u, const map_location& loc,
int move_left, paths::dest_vect &destinations,
std::vector<team> const &teams,
bool force_ignore_zocs, bool allow_teleport, int turns_left,
const team &viewing_team,
bool see_all, bool ignore_units)
{
const team& current_team = teams[u.side() - 1];
std::set<map_location> teleports;
if (allow_teleport) {
teleports = get_teleport_locations(u, units, viewing_team, see_all, ignore_units);
}
const int total_movement = u.total_movement();
std::vector<map_location> locs(6 + teleports.size());
std::copy(teleports.begin(), teleports.end(), locs.begin() + 6);
search_counter += 2;
if (search_counter == 0) search_counter = 2;
static std::vector<node> nodes;
nodes.resize(map.w() * map.h());
indexer index(map.w(), map.h());
comp node_comp(nodes);
int xmin = loc.x, xmax = loc.x, ymin = loc.y, ymax = loc.y, nb_dest = 1;
nodes[index(loc)] = node(move_left, turns_left, map_location::null_location, loc);
std::vector<int> pq;
pq.push_back(index(loc));
while (!pq.empty()) {
node& n = nodes[pq.front()];
std::pop_heap(pq.begin(), pq.end(), node_comp);
pq.pop_back();
n.in = search_counter;
get_adjacent_tiles(n.curr, &locs[0]);
for (int i = teleports.count(n.curr) ? locs.size() : 6; i-- > 0; ) {
if (!locs[i].valid(map.w(), map.h())) continue;
node& next = nodes[index(locs[i])];
bool next_visited = next.in - search_counter <= 1u;
// Classic Dijkstra allow to skip chosen nodes (with next.in==search_counter)
// But the cost function and hex grid allow to also skip visited nodes:
// if next was visited, then we already have a path 'src-..-n2-next'
// - n2 was chosen before n, meaning that it is nearer to src.
// - the cost of 'n-next' can't be smaller than 'n2-next' because
// cost is independent of direction and we don't have more MP at n
// (important because more MP may allow to avoid waiting next turn)
// Thus, 'src-..-n-next' can't be shorter.
if (next_visited) continue;
const int move_cost = u.movement_cost(map[locs[i]]);
node t = node(n.movement_left, n.turns_left, n.curr, locs[i]);
if (t.movement_left < move_cost) {
t.movement_left = total_movement;
t.turns_left--;
}
if (t.movement_left < move_cost || t.turns_left < 0) continue;
t.movement_left -= move_cost;
if (!ignore_units) {
const unit *v =
get_visible_unit(units, locs[i], viewing_team, see_all);
if (v && current_team.is_enemy(v->side()))
continue;
if (!force_ignore_zocs && t.movement_left > 0
&& enemy_zoc(units, teams, locs[i], viewing_team, u.side(), see_all)
&& !u.get_ability_bool("skirmisher", locs[i])) {
t.movement_left = 0;
}
}
++nb_dest;
int x = locs[i].x;
if (x < xmin) xmin = x;
if (xmax < x) xmax = x;
int y = locs[i].y;
if (y < ymin) ymin = y;
if (ymax < y) ymax = y;
bool in_list = next.in == search_counter + 1;
t.in = search_counter + 1;
next = t;
// if already in the priority queue then we just update it, else push it.
if (in_list) { // never happen see next_visited above
std::push_heap(pq.begin(), std::find(pq.begin(), pq.end(), index(locs[i])) + 1, node_comp);
} else {
pq.push_back(index(locs[i]));
std::push_heap(pq.begin(), pq.end(), node_comp);
}
}
}
// Build the routes for every map_location that we reached.
// The ordering must be compatible with map_location::operator<.
destinations.reserve(nb_dest);
for (int x = xmin; x <= xmax; ++x) {
for (int y = ymin; y <= ymax; ++y)
{
const node &n = nodes[index(map_location(x, y))];
if (n.in - search_counter > 1u) continue;
paths::step s =
{ n.curr, n.prev, n.movement_left + n.turns_left * total_movement };
destinations.push_back(s);
}
}
}
surface getMinimap(int w, int h, const gamemap &map, const team *vw)
{
const int scale = 8;
DBG_DP << "creating minimap " << int(map.w()*scale*0.75) << "," << map.h()*scale << "\n";
const size_t map_width = map.w()*scale*3/4;
const size_t map_height = map.h()*scale;
if(map_width == 0 || map_height == 0) {
return surface(NULL);
}
surface minimap(create_neutral_surface(map_width, map_height));
if(minimap == NULL)
return surface(NULL);
typedef mini_terrain_cache_map cache_map;
cache_map *normal_cache = &mini_terrain_cache;
cache_map *fog_cache = &mini_fogged_terrain_cache;
for(int y = 0; y != map.total_height(); ++y) {
for(int x = 0; x != map.total_width(); ++x) {
surface surf(NULL);
const map_location loc(x,y);
if(map.on_board(loc)) {
const bool shrouded = (vw != NULL && vw->shrouded(loc));
// shrouded hex are not considered fogged (no need to fog a black image)
const bool fogged = (vw != NULL && !shrouded && vw->fogged(loc));
const t_translation::t_terrain terrain = shrouded ?
t_translation::VOID_TERRAIN : map[loc];
const terrain_type& terrain_info = map.get_terrain_info(terrain);
bool need_fogging = false;
cache_map* cache = fogged ? fog_cache : normal_cache;
cache_map::iterator i = cache->find(terrain);
if (fogged && i == cache->end()) {
// we don't have the fogged version in cache
// try the normal cache and ask fogging the image
cache = normal_cache;
i = cache->find(terrain);
need_fogging = true;
}
if(i == cache->end()) {
std::string base_file =
"terrain/" + terrain_info.minimap_image() + ".png";
surface tile = get_image(base_file,image::HEXED);
//Compose images of base and overlay if necessary
// NOTE we also skip overlay when base is missing (to avoid hiding the error)
if(tile != NULL && map.get_terrain_info(terrain).is_combined()) {
std::string overlay_file =
"terrain/" + terrain_info.minimap_image_overlay() + ".png";
surface overlay = get_image(overlay_file,image::HEXED);
if(overlay != NULL && overlay != tile) {
surface combined = create_neutral_surface(tile->w, tile->h);
SDL_Rect r = create_rect(0,0,0,0);
sdl_blit(tile, NULL, combined, &r);
r.x = std::max(0, (tile->w - overlay->w)/2);
r.y = std::max(0, (tile->h - overlay->h)/2);
//blit_surface needs neutral surface
surface overlay_neutral = make_neutral_surface(overlay);
blit_surface(overlay_neutral, NULL, combined, &r);
tile = combined;
}
}
surf = scale_surface_sharp(tile, scale, scale);
i = normal_cache->insert(cache_map::value_type(terrain,surf)).first;
}
surf = i->second;
if (need_fogging) {
surf = adjust_surface_color(surf,-50,-50,-50);
fog_cache->insert(cache_map::value_type(terrain,surf));
}
// we need a balanced shift up and down of the hexes.
// if not, only the bottom half-hexes are clipped
// and it looks asymmetrical.
// also do 1-pixel shift because the scaling
// function seems to do it with its rounding
SDL_Rect maprect = create_rect(
x * scale * 3 / 4 - 1
, y * scale + scale / 4 * (is_odd(x) ? 1 : -1) - 1
, 0
, 0);
if(surf != NULL)
sdl_blit(surf, NULL, minimap, &maprect);
}
}
}
double wratio = w*1.0 / minimap->w;
double hratio = h*1.0 / minimap->h;
double ratio = std::min<double>(wratio, hratio);
minimap = scale_surface_sharp(minimap,
static_cast<int>(minimap->w * ratio), static_cast<int>(minimap->h * ratio));
DBG_DP << "done generating minimap\n";
return minimap;
}
void gamemap::overlay(const gamemap& m, const config& rules_cfg, int xpos, int ypos, bool border)
{
const config::const_child_itors &rules = rules_cfg.child_range("rule");
int actual_border = (m.border_size() == border_size()) && border ? border_size() : 0;
const int xstart = std::max<int>(-actual_border, -xpos - actual_border);
const int ystart = std::max<int>(-actual_border, -ypos - actual_border - ((xpos & 1) ? 1 : 0));
const int xend = std::min<int>(m.w() + actual_border, w() + actual_border - xpos);
const int yend = std::min<int>(m.h() + actual_border, h() + actual_border - ypos);
for(int x1 = xstart; x1 < xend; ++x1) {
for(int y1 = ystart; y1 < yend; ++y1) {
const int x2 = x1 + xpos;
const int y2 = y1 + ypos +
((xpos & 1) && (x1 & 1) ? 1 : 0);
const t_translation::t_terrain t = m[x1][y1 + m.border_size_];
const t_translation::t_terrain current = (*this)[x2][y2 + border_size_];
if(t == t_translation::FOGGED || t == t_translation::VOID_TERRAIN) {
continue;
}
// See if there is a matching rule
config::const_child_iterator rule = rules.first;
for( ; rule != rules.second; ++rule)
{
static const std::string src_key = "old", dst_key = "new";
const config &cfg = *rule;
const t_translation::t_list& src = t_translation::read_list(cfg[src_key]);
if(!src.empty() && t_translation::terrain_matches(current, src) == false) {
continue;
}
const t_translation::t_list& dst = t_translation::read_list(cfg[dst_key]);
if(!dst.empty() && t_translation::terrain_matches(t, dst) == false) {
continue;
}
break;
}
if (rule != rules.second)
{
const config &cfg = *rule;
const t_translation::t_list& terrain = t_translation::read_list(cfg["terrain"]);
terrain_type_data::tmerge_mode mode = terrain_type_data::BOTH;
if (cfg["layer"] == "base") {
mode = terrain_type_data::BASE;
}
else if (cfg["layer"] == "overlay") {
mode = terrain_type_data::OVERLAY;
}
t_translation::t_terrain new_terrain = t;
if(!terrain.empty()) {
new_terrain = terrain[0];
}
if (!cfg["use_old"].to_bool()) {
set_terrain(map_location(x2, y2), new_terrain, mode, cfg["replace_if_failed"].to_bool());
}
} else {
set_terrain(map_location(x2,y2),t);
}
}
}
for(const map_location* pos = m.startingPositions_;
pos != m.startingPositions_ + sizeof(m.startingPositions_)/sizeof(*m.startingPositions_);
++pos) {
if(pos->valid()) {
startingPositions_[pos - m.startingPositions_] = *pos;
}
}
}
bool editor_map::same_size_as(const gamemap& other) const
{
return h() == other.h()
&& w() == other.w();
}
surface getMinimap(int w, int h, const gamemap &map, const team *vw)
{
const int scale = 8;
DBG_DP << "creating minimap " << int(map.w()*scale*0.75) << "," << int(map.h()*scale) << "\n";
const size_t map_width = map.w()*scale*3/4;
const size_t map_height = map.h()*scale;
if(map_width == 0 || map_height == 0) {
return surface(NULL);
}
surface minimap(create_neutral_surface(map_width, map_height));
if(minimap == NULL)
return surface(NULL);
typedef mini_terrain_cache_map cache_map;
cache_map *normal_cache = &mini_terrain_cache;
cache_map *fog_cache = &mini_fogged_terrain_cache;
for(int y = 0; y != map.total_height(); ++y) {
for(int x = 0; x != map.total_width(); ++x) {
surface surf(NULL);
const map_location loc(x,y);
if(map.on_board(loc)) {
const bool shrouded = vw != NULL && vw->shrouded(loc);
// shrouded hex are not considered fogged (no need to fog a black image)
const bool fogged = vw != NULL && !shrouded && vw->fogged(loc);
const t_translation::t_terrain terrain = shrouded ?
t_translation::VOID_TERRAIN : map[loc];
bool need_fogging = false;
cache_map* cache = fogged ? fog_cache : normal_cache;
cache_map::iterator i = cache->find(terrain);
if (fogged && i == cache->end()) {
// we don't have the fogged version in cache
// try the normal cache and ask fogging the image
cache = normal_cache;
i = cache->find(terrain);
need_fogging = true;
}
if(i == cache->end()) {
surface tile(get_image("terrain/" + map.get_terrain_info(terrain).minimap_image() + ".png",image::HEXED));
if(tile == 0) {
utils::string_map symbols;
symbols["terrain"] = t_translation::write_terrain_code(terrain);
const std::string msg =
vgettext("Could not get image for terrain: $terrain.", symbols);
VALIDATE(false, msg);
}
//Compose images of base and overlay if neccessary
if(map.get_terrain_info(terrain).is_combined()) {
surface overlay(get_image("terrain/" + map.get_terrain_info(terrain).minimap_image_overlay() + ".png", image::HEXED));
if(overlay != 0 && overlay != tile) {
surface combined = create_compatible_surface(tile, tile->w, tile->h);
SDL_Rect r;
r.x = 0;
r.y = 0;
SDL_BlitSurface(tile, NULL, combined, &r);
r.x = std::max(0, (tile->w - overlay->w)/2);
r.y = std::max(0, (tile->h - overlay->h)/2);
if ((overlay->flags & SDL_RLEACCEL) == 0) {
blit_surface(overlay, NULL, combined, &r);
} else {
WRN_DP << map.get_terrain_info(terrain).minimap_image_overlay() << ".png overlay is RLE-encoded, creating a neutral surface\n";
surface overlay_neutral = make_neutral_surface(overlay);
blit_surface(overlay_neutral, NULL, combined, &r);
}
tile = combined;
}
}
surf = surface(scale_surface_blended(tile,scale,scale));
VALIDATE(surf != NULL, _("Error creating or aquiring an image."));
i = normal_cache->insert(cache_map::value_type(terrain,surf)).first;
}
surf = i->second;
if (need_fogging) {
surf = surface(adjust_surface_colour(surf,-50,-50,-50));
fog_cache->insert(cache_map::value_type(terrain,surf));
}
VALIDATE(surf != NULL, _("Error creating or aquiring an image."));
// we need a balanced shift up and down of the hexes.
// if not, only the bottom half-hexes are clipped
// and it looks asymmetrical.
// also do 1-pixel shift because the scaling
// function seems to do it with its rounding
SDL_Rect maprect = {x * scale*3/4 - 1,
y*scale + scale/4 * (is_odd(x) ? 1 : -1) - 1,
0, 0};
SDL_BlitSurface(surf, NULL, minimap, &maprect);
}
}
}
double wratio = w*1.0 / minimap->w;
double hratio = h*1.0 / minimap->h;
double ratio = std::min<double>(wratio, hratio);
minimap = scale_surface(minimap,
static_cast<int>(minimap->w * ratio), static_cast<int>(minimap->h * ratio));
DBG_DP << "done generating minimap\n";
return minimap;
}
