bool WorldSection::parseField(const std::string key, const std::string value,
ValidationList& validation) {
if (key == "input_dir") {
if (input_dir.load(key, value, validation)) {
input_dir.setValue(BOOST_FS_ABSOLUTE(input_dir.getValue(), config_dir));
if (!fs::is_directory(input_dir.getValue()))
validation.error("'input_dir' must be an existing directory! '"
+ input_dir.getValue().string() + "' does not exist!");
}
} else if (key == "dimension")
dimension.load(key, value, validation);
else if (key == "world_name")
world_name.load(key, value, validation);
else if (key == "default_view")
default_view.load(key, value, validation);
else if (key == "default_zoom")
default_zoom.load(key, value, validation);
else if (key == "default_rotation") {
int rotation = stringToRotation(value, ROTATION_NAMES);
if (rotation == -1)
validation.error("Invalid rotation '" + value + "'!");
default_rotation.setValue(rotation);
}
else if (key == "crop_min_y") {
if (min_y.load(key, value, validation))
world_crop.setMinY(min_y.getValue());
} else if (key == "crop_max_y") {
if (max_y.load(key, value, validation))
world_crop.setMaxY(max_y.getValue());
} else if (key == "crop_min_x") {
if (min_x.load(key, value, validation))
world_crop.setMinX(min_x.getValue());
} else if (key == "crop_max_x") {
if (max_x.load(key, value, validation))
world_crop.setMaxX(max_x.getValue());
} else if (key == "crop_min_z") {
if (min_z.load(key, value, validation))
world_crop.setMinZ(min_z.getValue());
} else if (key == "crop_max_z") {
if (max_z.load(key, value, validation))
world_crop.setMaxZ(max_z.getValue());
}
else if (key == "crop_center_x")
center_x.load(key, value, validation);
else if (key == "crop_center_z")
center_z.load(key, value, validation);
else if (key == "crop_radius")
radius.load(key, value, validation);
else if (key == "crop_unpopulated_chunks")
crop_unpopulated_chunks.load(key, value, validation);
else if (key == "block_mask")
block_mask.load(key, value, validation);
else
return false;
return true;
}
void MapSection::postParse(const INIConfigSection& section,
ValidationList& validation) {
// parse rotations
rotations_set.clear();
tile_sets.clear();
std::string str = rotations.getValue();
std::stringstream ss;
ss << str;
std::string elem;
while (ss >> elem) {
int r = stringToRotation(elem);
if (r != -1) {
rotations_set.insert(r);
tile_sets.insert(getTileSet(r));
} else {
validation.error("Invalid rotation '" + elem + "'!");
}
}
// check if required options were specified
if (!isGlobal()) {
world.require(validation, "You have to specify a world ('world')!");
texture_dir.require(validation, "You have to specify a texture directory ('texture_dir')!");
}
}
bool isValidationValid(const ValidationList& validation) {
auto messages = validation.getMessages();
for (auto message_it = messages.begin(); message_it != messages.end(); ++message_it)
if (message_it->getType() == ValidationMessage::ERROR)
return false;
return true;
}
bool ConfigSectionBase::parse(const INIConfigSection& section,
ValidationList& validation) {
section_name = section.getName();
preParse(section, validation);
auto entries = section.getEntries();
for (auto entry_it = entries.begin(); entry_it != entries.end(); ++entry_it) {
std::string key = entry_it->first;
std::string value = entry_it->second;
if (!parseField(key, value, validation))
validation.push_back(ValidationMessage::warning(
"Unknown configuration option '" + key + "'!"));
}
postParse(section, validation);
return isValidationValid(validation);
}
void MarkerSection::postParse(const INIConfigSection& section,
ValidationList& validation) {
text_format.setDefault(title_format.getValue());
// check if the old placeholders are used, just search for %placeholder
// they are still supported, but show a warning
std::vector<std::string> placeholders = {
"text", "textp", "prefix", "line1", "line2", "line3", "line4", "x", "y", "z"
};
for (auto it = placeholders.begin(); it != placeholders.end(); ++it) {
std::string placeholder = "%" + *it;
if (title_format.getValue().find(placeholder) != std::string::npos
|| text_format.getValue().find(placeholder) != std::string::npos) {
validation.warning("It seems you are using the old placeholder format "
"for 'title_format' or 'text_format'. Please use '%(placeholder)' "
"instead of '%placeholder'.");
return;
}
}
}
void WorldSection::postParse(const INIConfigSection& section,
ValidationList& validation) {
if (default_zoom.isLoaded() && default_zoom.getValue() < 0)
validation.error("The default zoom level must be bigger or equal to 0 ('default_zoom').");
// validate the world croppping
bool crop_rectangular = min_x.isLoaded() || max_x.isLoaded() || min_z.isLoaded() || max_z.isLoaded();
bool crop_circular = center_x.isLoaded() || center_z.isLoaded() || radius.isLoaded();
if (crop_rectangular && crop_circular) {
validation.error("You can not use both world cropping types at the same time!");
} else if (crop_rectangular) {
if (min_x.isLoaded() && max_x.isLoaded() && min_x.getValue() > max_x.getValue())
validation.error("min_x must be smaller than or equal to max_x!");
if (min_z.isLoaded() && max_z.isLoaded() && min_z.getValue() > max_z.getValue())
validation.error("min_z must be smaller than or equal to max_z!");
} else if (crop_circular) {
std::string message = "You have to specify crop_center_x, crop_center_z "
"and crop_radius for circular world cropping!";
center_x.require(validation, message)
&& center_z.require(validation, message)
&& radius.require(validation, message);
world_crop.setCenter(mc::BlockPos(center_x.getValue(), center_z.getValue(), 0));
world_crop.setRadius(radius.getValue());
}
if (min_y.isLoaded() && max_y.isLoaded() && min_y.getValue() > max_y.getValue())
validation.error("min_y must be smaller than or equal to max_y!");
world_crop.setCropUnpopulatedChunks(crop_unpopulated_chunks.getValue());
if (block_mask.isLoaded()) {
try {
world_crop.loadBlockMask(block_mask.getValue());
} catch (std::invalid_argument& exception) {
validation.error(std::string("There is a problem parsing the block mask: ")
+ exception.what());
}
}
// check if required options were specified
if (!isGlobal()) {
input_dir.require(validation, "You have to specify an input directory ('input_dir')!");
}
}
bool MapcrafterConfig::parse(const std::string& filename, ValidationMap& validation) {
INIConfig config;
ValidationMessage msg;
if (!config.loadFile(filename, msg)) {
validation.push_back(std::make_pair("Configuration file", makeValidationList(msg)));
return false;
}
fs::path config_dir = fs::path(filename).parent_path();
bool ok = true;
ValidationList general_msgs;
bool has_default_template = !util::findTemplateDir().empty();
if (has_default_template)
template_dir.setDefault(util::findTemplateDir());
auto entries = config.getRootSection().getEntries();
for (auto entry_it = entries.begin(); entry_it != entries.end(); ++entry_it) {
std::string key = entry_it->first;
std::string value = entry_it->second;
if (key == "output_dir") {
if (output_dir.load(key, value, general_msgs))
output_dir.setValue(BOOST_FS_ABSOLUTE(output_dir.getValue(), config_dir));
} else if (key == "template_dir") {
if (template_dir.load(key, value, general_msgs)) {
template_dir.setValue(BOOST_FS_ABSOLUTE(template_dir.getValue(), config_dir));
if (!fs::is_directory(template_dir.getValue()))
general_msgs.push_back(ValidationMessage::error(
"'template_dir' must be an existing directory! '"
+ template_dir.getValue().string() + "' does not exist!"));
}
} else {
general_msgs.push_back(ValidationMessage::warning(
"Unknown configuration option '" + key + "'!"));
}
}
if (!output_dir.require(general_msgs, "You have to specify an output directory ('output_dir')!"))
ok = false;
if (!has_default_template)
template_dir.require(general_msgs, "You have to specify a template directory ('template_dir')!");
if (!general_msgs.empty())
validation.push_back(std::make_pair("Configuration file", general_msgs));
if (config.hasSection("global", "worlds")) {
ValidationList msgs;
world_global.setConfigDir(config_dir);
ok = world_global.parse(config.getSection("global", "worlds"), msgs) && ok;
if (!msgs.empty())
validation.push_back(std::make_pair("Global world configuration", msgs));
if (!ok)
return false;
}
if (config.hasSection("global", "maps")) {
ValidationList msgs;
map_global.setConfigDir(config_dir);
ok = map_global.parse(config.getSection("global", "maps"), msgs) && ok;
if (!msgs.empty())
validation.push_back(std::make_pair("Global map configuration", msgs));
if (!ok)
return false;
}
auto sections = config.getSections();
for (auto it = sections.begin(); it != sections.end(); ++it)
if (it->getType() != "world" && it->getType() != "map"
&& it->getNameType() != "global:worlds"
&& it->getNameType() != "global:maps") {
validation.push_back(std::make_pair("Section '" + it->getName() + "' with type '" + it->getType() + "'",
makeValidationList(ValidationMessage::warning("Unknown section type!"))));
}
for (auto it = sections.begin(); it != sections.end(); ++it) {
if (it->getType() != "world")
continue;
ValidationList msgs;
WorldSection world = world_global;
world.setGlobal(false);
world.setConfigDir(config_dir);
ok = world.parse(*it, msgs) && ok;
if (hasWorld(it->getName())) {
msgs.push_back(ValidationMessage::error("World name '" + it->getName() + "' already used!"));
ok = false;
} else
worlds[it->getName()] = world;
if (!msgs.empty())
validation.push_back(std::make_pair("World section '" + it->getName() + "'", msgs));
}
for (auto it = sections.begin(); it != sections.end(); ++it) {
if (it->getType() != "map")
continue;
ValidationList msgs;
MapSection map = map_global;
map.setGlobal(false);
map.setConfigDir(config_dir);
ok = map.parse(*it, msgs) && ok;
if (hasMap(it->getName())) {
msgs.push_back(ValidationMessage::error("Map name '" + it->getName() + "' already used!"));
ok = false;
} else if (map.getWorld() != "" && !hasWorld(map.getWorld())) {
msgs.push_back(ValidationMessage::error("World '" + map.getWorld() + "' does not exist!"));
ok = false;
} else
maps.push_back(map);
if (!msgs.empty())
validation.push_back(std::make_pair("Map section '" + it->getName() + "'", msgs));
}
return ok;
}
bool MapSection::parseField(const std::string key, const std::string value,
ValidationList& validation) {
if (key == "name") {
name_long = value;
} else if (key == "world") {
world.load(key, value, validation);
} else if (key == "render_view") {
render_view.load(key, value, validation);
} else if (key == "render_mode" || key == "rendermode") {
render_mode.load(key, value, validation);
if (key == "rendermode")
validation.warning("Using the option 'rendermode' is deprecated. "
"It's called 'render_mode' now.");
} else if (key == "overlay") {
overlay.load(key, value, validation);
} else if (key == "rotations") {
rotations.load(key, value ,validation);
} else if (key == "texture_dir") {
if (texture_dir.load(key, value, validation)) {
texture_dir.setValue(BOOST_FS_ABSOLUTE(texture_dir.getValue(), config_dir));
if (!fs::is_directory(texture_dir.getValue()))
validation.error("'texture_dir' must be an existing directory! '"
+ texture_dir.getValue().string() + "' does not exist!");
}
} else if (key == "texture_blur") {
texture_blur.load(key, value, validation);
} else if (key == "texture_size") {
if (texture_size.load(key, value, validation)
&& (texture_size.getValue() <= 0 || texture_size.getValue() > 32))
validation.error("'texture_size' must be a number between 1 and 32!");
} else if (key == "water_opacity") {
if (water_opacity.load(key, value, validation)
&& (water_opacity.getValue() < 0 || water_opacity.getValue() >= 1.0))
validation.error("'water_opacity' must be a number between 0.0 and 1.0!");
} else if (key == "tile_width") {
tile_width.load(key, value, validation);
if (tile_width.getValue() < 1)
validation.error("'tile_width' must be a positive number!");
} else if (key == "image_format") {
image_format.load(key, value, validation);
} else if (key == "png_indexed") {
png_indexed.load(key, value, validation);
} else if (key == "jpeg_quality") {
if (jpeg_quality.load(key, value, validation)
&& (jpeg_quality.getValue() < 0 || jpeg_quality.getValue() > 100))
validation.error("'jpeg_quality' must be a number between 0 and 100!");
} else if (key == "lighting_intensity") {
lighting_intensity.load(key, value, validation);
} else if (key == "lighting_water_intensity") {
lighting_water_intensity.load(key, value, validation);
} else if (key == "render_unknown_blocks") {
render_unknown_blocks.load(key, value, validation);
} else if (key == "render_leaves_transparent") {
render_leaves_transparent.load(key, value, validation);
} else if (key == "render_biomes") {
render_biomes.load(key, value, validation);
} else if (key == "use_image_mtimes") {
use_image_mtimes.load(key, value, validation);
} else
return false;
return true;
}
bool isValidationValid(const ValidationList& validation) {
for (auto it = validation.begin(); it != validation.end(); ++it)
if (it->getType() == ValidationMessage::ERROR)
return false;
return true;
}
ValidationList makeValidationList(const ValidationMessage& msg) {
ValidationList validation;
validation.push_back(msg);
return validation;
}
ValidationList makeValidationList(const ValidationMessage& msg) {
ValidationList validation;
validation.message(msg);
return validation;
}
