t_translation::t_terrain gamemap::merge_terrains(const t_translation::t_terrain old_t, const t_translation::t_terrain new_t, const tmerge_mode mode, bool replace_if_failed) { t_translation::t_terrain result = t_translation::NONE_TERRAIN; if(mode == OVERLAY) { const t_translation::t_terrain t = t_translation::t_terrain(old_t.base, new_t.overlay); if (try_merge_terrains(t)) { result = t; } } else if(mode == BASE) { const t_translation::t_terrain t = t_translation::t_terrain(new_t.base, old_t.overlay); if (try_merge_terrains(t)) { result = t; } } else if(mode == BOTH && new_t.base != t_translation::NO_LAYER) { // We need to merge here, too, because the dest terrain might be a combined one. if (try_merge_terrains(new_t)) { result = new_t; } } // if merging of overlay and base failed, and replace_if_failed is set, // replace the terrain with the complete new terrain (if given) // or with (default base)^(new overlay) if(result == t_translation::NONE_TERRAIN && replace_if_failed && tcodeToTerrain_.count(new_t) > 0) { if(new_t.base != t_translation::NO_LAYER) { // Same as above if (try_merge_terrains(new_t)) { result = new_t; } } else if (get_terrain_info(new_t).default_base() != t_translation::NONE_TERRAIN) { result = get_terrain_info(new_t).terrain_with_default_base(); } } return result; }
void gamemap::read(const std::string& data) { // Initial stuff tiles_.clear(); villages_.clear(); std::fill(startingPositions_, startingPositions_ + sizeof(startingPositions_) / sizeof(*startingPositions_), map_location()); std::map<int, t_translation::coordinate> starting_positions; if(data.empty()) { w_ = 0; h_ = 0; return; } // Test whether there is a header section size_t header_offset = data.find("\n\n"); if(header_offset == std::string::npos) { // For some reason Windows will fail to load a file with \r\n // lineending properly no problems on Linux with those files. // This workaround fixes the problem the copy later will copy // the second \r\n to the map, but that's no problem. header_offset = data.find("\r\n\r\n"); } const size_t comma_offset = data.find(","); // The header shouldn't contain commas, so if the comma is found // before the header, we hit a \n\n inside or after a map. // This is no header, so don't parse it as it would be. VALIDATE( !(header_offset == std::string::npos || comma_offset < header_offset), _("A map without a header is not supported")); std::string header_str(std::string(data, 0, header_offset + 1)); config header; ::read(header, header_str); border_size_ = lexical_cast_default<int>(header["border_size"], 0); const std::string usage = header["usage"]; utils::string_map symbols; symbols["border_size_key"] = "border_size"; symbols["usage_key"] = "usage"; symbols["usage_val"] = usage; const std::string msg = "'$border_size_key|' should be " "'$border_size_val|' when '$usage_key| = $usage_val|'"; if(usage == "map") { usage_ = IS_MAP; symbols["border_size_val"] = "1"; VALIDATE(border_size_ == 1, vgettext(msg.c_str(), symbols)); } else if(usage == "mask") { usage_ = IS_MASK; symbols["border_size_val"] = "0"; VALIDATE(border_size_ == 0, vgettext(msg.c_str(), symbols)); } else if(usage == "") { throw incorrect_map_format_exception("Map has a header but no usage"); } else { std::string msg = "Map has a header but an unknown usage:" + usage; throw incorrect_map_format_exception(msg.c_str()); } /* The third parameter is required for MSVC++ 6.0 */ const std::string& map = std::string(data, header_offset + 2, std::string::npos); try { tiles_ = t_translation::read_game_map(map, starting_positions); } catch(t_translation::error& e) { // We re-throw the error but as map error. // Since all codepaths test for this, it's the least work. throw incorrect_map_format_exception(e.message); } // Convert the starting positions to the array std::map<int, t_translation::coordinate>::const_iterator itor = starting_positions.begin(); for(; itor != starting_positions.end(); ++itor) { // Check for valid position, // the first valid position is 1, // so the offset 0 in the array is never used. if(itor->first < 1 || itor->first >= MAX_PLAYERS+1) { std::stringstream ss; ss << "Starting position " << itor->first << " out of range\n"; ERR_CF << ss.str(); ss << "The map cannot be loaded."; throw incorrect_map_format_exception(ss.str().c_str()); } // Add to the starting position array startingPositions_[itor->first] = map_location(itor->second.x - 1, itor->second.y - 1); } // Post processing on the map total_width_ = tiles_.size(); total_height_ = total_width_ > 0 ? tiles_[0].size() : 0; w_ = total_width_ - 2 * border_size_; h_ = total_height_ - 2 * border_size_; for(int x = 0; x < total_width_; ++x) { for(int y = 0; y < total_height_; ++y) { // Is the terrain valid? if(tcodeToTerrain_.count(tiles_[x][y]) == 0) { if(!try_merge_terrains(tiles_[x][y])) { std::stringstream ss; ss << "Illegal character in map: (" << t_translation::write_terrain_code(tiles_[x][y]) << ") '" << tiles_[x][y] << "'\n"; ERR_CF << ss.str(); ss << "The map cannot be loaded."; throw incorrect_map_format_exception(ss.str().c_str()); } } // Is it a village? if(x >= border_size_ && y >= border_size_ && x < total_width_-border_size_ && y < total_height_-border_size_ && is_village(tiles_[x][y])) { villages_.push_back(map_location(x-border_size_, y-border_size_)); } } } }
void gamemap::read(const std::string& data, const bool allow_invalid, int border_size, std::string usage) { // Initial stuff border_size_ = border_size; set_usage(usage); tiles_.clear(); villages_.clear(); std::fill(startingPositions_, startingPositions_ + sizeof(startingPositions_) / sizeof(*startingPositions_), map_location()); std::map<int, t_translation::coordinate> starting_positions; if(data.empty()) { w_ = 0; h_ = 0; total_width_ = 0; total_height_ = 0; if(allow_invalid) return; } int offset = read_header(data); const std::string& data_only = std::string(data, offset); try { tiles_ = t_translation::read_game_map(data_only, starting_positions); } catch(t_translation::error& e) { // We re-throw the error but as map error. // Since all codepaths test for this, it's the least work. throw incorrect_map_format_error(e.message); } // Convert the starting positions to the array std::map<int, t_translation::coordinate>::const_iterator itor = starting_positions.begin(); for(; itor != starting_positions.end(); ++itor) { // Check for valid position, // the first valid position is 1, // so the offset 0 in the array is never used. if(itor->first < 1 || itor->first >= MAX_PLAYERS+1) { std::stringstream ss; ss << "Starting position " << itor->first << " out of range\n"; ERR_CF << ss.str(); ss << "The map cannot be loaded."; throw incorrect_map_format_error(ss.str().c_str()); } // Add to the starting position array startingPositions_[itor->first] = map_location(itor->second.x - 1, itor->second.y - 1); } // Post processing on the map total_width_ = tiles_.size(); total_height_ = total_width_ > 0 ? tiles_[0].size() : 0; w_ = total_width_ - 2 * border_size_; h_ = total_height_ - 2 * border_size_; //Disabled since there are callcases which pass along a valid map header but empty //map data. Still, loading (and actually applying) an empty map causes problems later on. //Other callcases which need to load a dummy map use completely empty data :(. //VALIDATE((w_ >= 1 && h_ >= 1), "A map needs at least 1 tile, the map cannot be loaded."); for(int x = 0; x < total_width_; ++x) { for(int y = 0; y < total_height_; ++y) { // Is the terrain valid? if(tcodeToTerrain_.count(tiles_[x][y]) == 0) { if(!try_merge_terrains(tiles_[x][y])) { std::stringstream ss; ss << "Illegal tile in map: (" << t_translation::write_terrain_code(tiles_[x][y]) << ") '" << tiles_[x][y] << "'\n"; ERR_CF << ss.str(); ss << "The map cannot be loaded."; throw incorrect_map_format_error(ss.str().c_str()); } } // Is it a village? if(x >= border_size_ && y >= border_size_ && x < total_width_-border_size_ && y < total_height_-border_size_ && is_village(tiles_[x][y])) { villages_.push_back(map_location(x-border_size_, y-border_size_)); } } } }