/**
* Updates *this based on @a vcfg.
* This corresponds to what can appear in [set_menu_item].
*/
void wml_menu_item::update(const vconfig & vcfg)
{
const bool old_use_hotkey = use_hotkey_;
// Tracks whether or not the hotkey has been updated.
bool hotkey_updated = false;
if ( vcfg.has_attribute("image") )
image_ = vcfg["image"].str();
if ( vcfg.has_attribute("description") ) {
description_ = vcfg["description"].t_str();
hotkey_updated = true;
}
if ( vcfg.has_attribute("needs_select") )
needs_select_ = vcfg["needs_select"].to_bool();
if ( const vconfig & child = vcfg.child("show_if") ) {
show_if_ = child;
show_if_.make_safe();
}
if ( const vconfig & child = vcfg.child("filter_location") ) {
filter_location_ = child;
filter_location_.make_safe();
}
if ( const vconfig & child = vcfg.child("default_hotkey") ) {
default_hotkey_ = child.get_parsed_config();
hotkey_updated = true;
}
if ( vcfg.has_attribute("use_hotkey") ) {
const config::attribute_value & use_hotkey_av = vcfg["use_hotkey"];
use_hotkey_ = use_hotkey_av.to_bool(true);
use_wml_menu_ = use_hotkey_av.str() != "only";
}
if ( const vconfig & cmd = vcfg.child("command") ) {
const bool delayed = cmd["delayed_variable_substitution"].to_bool(true);
update_command(delayed ? cmd.get_config() : cmd.get_parsed_config());
}
// Update the registered hotkey?
if ( use_hotkey_ && !old_use_hotkey )
// The hotkey needs to be enabled.
hotkey::add_wml_hotkey(hotkey_id_, description_, default_hotkey_);
else if ( use_hotkey_ && hotkey_updated )
// The hotkey needs to be updated.
hotkey::add_wml_hotkey(hotkey_id_, description_, default_hotkey_);
else if ( !use_hotkey_ && old_use_hotkey )
// The hotkey needs to be disabled.
hotkey::remove_wml_hotkey(hotkey_id_);
}
void verify_and_get_global_variable(const vconfig &pcfg)
{
bool valid = true;
if (!pcfg.has_attribute("from_global")) {
LOG_PERSIST << "Error: [get_global_variable] missing required attribute \"from_global\"";
valid = false;
}
if (!pcfg.has_attribute("to_local")) {
LOG_PERSIST << "Error: [get_global_variable] missing required attribute \"to_local\"";
valid = false;
}
// TODO: allow for global namespace.
if (!pcfg.has_attribute("namespace")) {
LOG_PERSIST << "Error: [get_global_variable] missing attribute \"namespace\" and no global namespace provided.";
valid = false;
}
if (network::nconnections() != 0) {
if (!pcfg.has_attribute("side")) {
LOG_PERSIST << "Error: [get_global_variable] missing attribute \"side\" required in multiplayer context.";
valid = false;
}
else {
config::attribute_value pcfg_side = pcfg["side"];
int side = pcfg_side.str() == "global" ? resources::controller->current_side() : pcfg_side.to_int();
if (unsigned (side - 1) >= resources::teams->size()) {
LOG_PERSIST << "Error: [get_global_variable] attribute \"side\" specifies invalid side number.";
valid = false;
} else {
if ((side != resources::controller->current_side())
&& !((*resources::teams)[side - 1].is_local())) {
if ((*resources::teams)[resources::controller->current_side() - 1].is_local()) {
config data;
data.add_child("wait_global");
data.child("wait_global")["side"] = side;
network::send_data(data,0);
}
while (get_replay_source().at_end()) {
ai::manager::raise_user_interact();
ai::manager::raise_sync_network();
SDL_Delay(10);
}
}
}
}
}
if (valid)
{
persist_context &ctx = resources::persist->get_context((pcfg["namespace"]));
if (ctx.valid()) {
get_global_variable(ctx,pcfg);
} else {
LOG_PERSIST << "Error: [get_global_variable] attribute \"namespace\" is not valid.";
}
}
}
void verify_and_set_global_variable(const vconfig &pcfg)
{
bool valid = true;
if (!pcfg.has_attribute("to_global")) {
LOG_PERSIST << "Error: [set_global_variable] missing required attribute \"from_global\"";
valid = false;
}
if (!pcfg.has_attribute("from_local")) {
LOG_PERSIST << "Warning: [set_global_variable] missing attribute \"to_local\", global variable will be cleared";
}
// TODO: allow for global namespace.
if (!pcfg.has_attribute("namespace")) {
LOG_PERSIST << "Error: [set_global_variable] missing attribute \"namespace\" and no global namespace provided.";
valid = false;
}
if (network::nconnections() != 0) {
if (!pcfg.has_attribute("side")) {
LOG_PERSIST << "Error: [set_global_variable] missing attribute \"side\" required in multiplayer context.";
valid = false;
} else {
config::attribute_value pcfg_side = pcfg["side"];
int side = pcfg_side;
//Check side matching only if the side is not "global".
if (pcfg_side.str() != "global") {
//Ensure that the side is valid.
if (unsigned(side-1) > resources::teams->size()) {
LOG_PERSIST << "Error: [set_global_variable] attribute \"side\" specifies invalid side number.";
valid = false;
} else {
//Set the variable only if it is meant for a side we control
valid = (*resources::teams)[side - 1].is_local();
}
}
}
}
if (valid)
{
persist_context &ctx = resources::persist->get_context((pcfg["namespace"]));
if (ctx.valid()) {
set_global_variable(ctx,pcfg);
} else {
LOG_PERSIST << "Error: [set_global_variable] attribute \"namespace\" is not valid.";
}
}
}
void verify_and_get_global_variable(const vconfig &pcfg)
{
bool valid = true;
if (!pcfg.has_attribute("from_global")) {
LOG_PERSIST << "Error: [get_global_variable] missing required attribute \"from_global\"";
valid = false;
}
if (!pcfg.has_attribute("to_local")) {
LOG_PERSIST << "Error: [get_global_variable] missing required attribute \"to_local\"";
valid = false;
}
// TODO: allow for global namespace.
if (!pcfg.has_attribute("namespace")) {
LOG_PERSIST << "Error: [get_global_variable] missing attribute \"namespace\" and no global namespace provided.";
valid = false;
}
if (network::nconnections() != 0) {
if (!pcfg.has_attribute("side")) {
LOG_PERSIST << "Error: [get_global_variable] missing attribute \"side\" required in multiplayer context.";
valid = false;
}
else {
DBG_PERSIST << "verify_and_get_global_variable with from_global=" << pcfg["from_global"] << " from side " << pcfg["side"] << "\n";
config::attribute_value pcfg_side = pcfg["side"];
int side = pcfg_side.str() == "global" ? resources::controller->current_side() : pcfg_side.to_int();
if (unsigned (side - 1) >= resources::teams->size()) {
LOG_PERSIST << "Error: [get_global_variable] attribute \"side\" specifies invalid side number." << "\n";
valid = false;
}
else
{
}
DBG_PERSIST << "end verify_and_get_global_variable with from_global=" << pcfg["from_global"] << " from side " << pcfg["side"] << "\n";
}
}
if (valid)
{
persist_context &ctx = resources::persist->get_context((pcfg["namespace"]));
if (ctx.valid()) {
get_global_variable(ctx,pcfg);
} else {
LOG_PERSIST << "Error: [get_global_variable] attribute \"namespace\" is not valid.";
}
}
}
bool have_location(const vconfig& cfg)
{
std::set<map_location> res;
terrain_filter(cfg, resources::filter_con).get_locations(res);
std::vector<std::pair<int,int> > counts = cfg.has_attribute("count")
? utils::parse_ranges(cfg["count"]) : default_counts;
return in_ranges<int>(res.size(), counts);
}
void verify_and_set_global_variable(const vconfig &pcfg)
{
bool valid = true;
if (!pcfg.has_attribute("to_global")) {
ERR_PERSIST << "[set_global_variable] missing required attribute \"to_global\"";
valid = false;
}
if (!pcfg.has_attribute("from_local")) {
LOG_PERSIST << "Warning: [set_global_variable] missing attribute \"from_local\", global variable will be cleared";
}
// TODO: allow for global namespace.
if (!pcfg.has_attribute("namespace")) {
ERR_PERSIST << "[set_global_variable] missing attribute \"namespace\" and no global namespace provided.";
valid = false;
}
if (resources::controller->is_networked_mp()) {
config::attribute_value pcfg_side = pcfg["side"];
int side = pcfg_side;
//Check side matching only if the side is not "global" or empty.
if (pcfg_side.str() != "global" && !pcfg_side.empty()) {
//Ensure that the side is valid.
if (unsigned(side-1) > resources::gameboard->teams().size()) {
ERR_PERSIST << "[set_global_variable] attribute \"side\" specifies invalid side number.";
valid = false;
} else if (resources::gameboard->teams()[side - 1].is_empty()) {
LOG_PERSIST << "[set_global_variable] attribute \"side\" specifies a null-controlled side number.";
valid = false;
} else {
//Set the variable only if it is meant for a side we control
valid = resources::gameboard->teams()[side - 1].is_local();
}
}
}
if (valid)
{
persist_context &ctx = resources::persist->get_context((pcfg["namespace"]));
if (ctx.valid()) {
set_global_variable(ctx,pcfg);
} else {
LOG_PERSIST << "Error: [set_global_variable] attribute \"namespace\" is not valid.";
}
}
}
void verify_and_clear_global_variable(const vconfig &pcfg)
{
bool valid = true;
if (!pcfg.has_attribute("global")) {
ERR_PERSIST << "[clear_global_variable] missing required attribute \"from_global\"";
valid = false;
}
if (!pcfg.has_attribute("namespace")) {
ERR_PERSIST << "[clear_global_variable] missing attribute \"namespace\" and no global namespace provided.";
valid = false;
}
if (network::nconnections() != 0) {
config::attribute_value pcfg_side = pcfg["side"];
const int side = pcfg_side.to_int();
//Check side matching only if the side is not "global" or empty.
if (pcfg_side.str() != "global" && !pcfg_side.empty()) {
//Ensure that the side is valid.
if (unsigned(side-1) > resources::teams->size()) {
ERR_PERSIST << "[clear_global_variable] attribute \"side\" specifies invalid side number.";
valid = false;
} else if ((*resources::teams)[side - 1].is_empty()) {
LOG_PERSIST << "[clear_global_variable] attribute \"side\" specifies a null-controlled side number.";
valid = false;
} else {
//Clear the variable only if it is meant for a side we control
valid = (*resources::teams)[side - 1].is_local();
}
}
}
if (valid)
{
persist_context &ctx = resources::persist->get_context((pcfg["namespace"]));
if (ctx.valid()) {
clear_global_variable(ctx,pcfg);
} else {
LOG_PERSIST << "Error: [clear_global_variable] attribute \"namespace\" is not valid.";
}
}
}
void verify_and_get_global_variable(const vconfig &pcfg)
{
bool valid = true;
if (!pcfg.has_attribute("from_global")) {
ERR_PERSIST << "[get_global_variable] missing required attribute \"from_global\"";
valid = false;
}
if (!pcfg.has_attribute("to_local")) {
ERR_PERSIST << "[get_global_variable] missing required attribute \"to_local\"";
valid = false;
}
// TODO: allow for global namespace.
if (!pcfg.has_attribute("namespace")) {
ERR_PERSIST << "[get_global_variable] missing attribute \"namespace\"";
valid = false;
}
if (resources::controller->is_networked_mp()) {
DBG_PERSIST << "verify_and_get_global_variable with from_global=" << pcfg["from_global"] << " from side " << pcfg["side"] << "\n";
config::attribute_value pcfg_side = pcfg["side"];
int side = (pcfg_side.str() == "global" || pcfg_side.empty()) ? resources::controller->current_side() : pcfg_side.to_int();
if (unsigned (side - 1) >= resources::gameboard->teams().size()) {
ERR_PERSIST << "[get_global_variable] attribute \"side\" specifies invalid side number." << "\n";
valid = false;
}
DBG_PERSIST << "end verify_and_get_global_variable with from_global=" << pcfg["from_global"] << " from side " << pcfg["side"] << "\n";
}
if (valid)
{
persist_context &ctx = resources::persist->get_context((pcfg["namespace"]));
if (ctx.valid()) {
get_global_variable(ctx,pcfg);
} else {
LOG_PERSIST << "Error: [get_global_variable] attribute \"namespace\" is not valid.";
}
}
}
bool have_unit(const vconfig& cfg)
{
if(resources::units == nullptr) {
return false;
}
std::vector<std::pair<int,int> > counts = cfg.has_attribute("count")
? utils::parse_ranges(cfg["count"]) : default_counts;
int match_count = 0;
const unit_filter ufilt(cfg, resources::filter_con);
for(const unit &i : *resources::units) {
if(i.hitpoints() > 0 && ufilt(i)) {
++match_count;
if(counts == default_counts) {
// by default a single match is enough, so avoid extra work
break;
}
}
}
if(cfg["search_recall_list"].to_bool()) {
for(const team& team : resources::gameboard->teams()) {
if(counts == default_counts && match_count) {
break;
}
for(size_t t = 0; t < team.recall_list().size(); ++t) {
if(counts == default_counts && match_count) {
break;
}
scoped_recall_unit auto_store("this_unit", team.save_id(), t);
if(ufilt(*team.recall_list()[t])) {
++match_count;
}
}
}
}
return in_ranges(match_count, counts);
}
void part::resolve_wml(const vconfig &cfg)
{
if(cfg.null()) {
return;
}
// Converts shortcut syntax to members of [background_layer]
background_layer bl;
if(cfg.has_attribute("background")) {
bl.set_file(cfg["background"].str());
}
if(cfg.has_attribute("scale_background")) {
bl.set_scale_horizontally(cfg["scale_background"].to_bool(true));
bl.set_scale_vertically(cfg["scale_background"].to_bool(true));
} else {
if(cfg.has_attribute("scale_background_vertically")) {
bl.set_scale_vertically(cfg["scale_background_vertically"].to_bool(true));
}
if(cfg.has_attribute("scale_background_horizontally")) {
bl.set_scale_horizontally(cfg["scale_background_horizontally"].to_bool(true));
}
}
if(cfg.has_attribute("tile_background")) {
bl.set_tile_horizontally(cfg["tile_background"].to_bool(false));
bl.set_tile_vertically(cfg["tile_background"].to_bool(false));
} else {
if(cfg.has_attribute("tile_background_vertically")) {
bl.set_tile_vertically(cfg["tile_background_vertically"].to_bool(false));
}
if(cfg.has_attribute("tile_background_horizontally")) {
bl.set_tile_vertically(cfg["tile_background_horizontally"].to_bool(false));
}
}
if(cfg.has_attribute("keep_aspect_ratio")) {
bl.set_keep_aspect_ratio(cfg["keep_aspect_ratio"].to_bool(true));
}
background_layers_.push_back(bl);
if(cfg.has_attribute("show_title")) {
show_title_ = cfg["show_title"].to_bool();
}
if(cfg.has_attribute("story")) {
text_ = cfg["story"].str();
}
if(cfg.has_attribute("title")) {
text_title_ = cfg["title"].str();
if(!cfg.has_attribute("show_title")) {
show_title_ = true;
}
}
if(cfg.has_attribute("text_layout")) {
text_block_loc_ = string_tblock_loc(cfg["text_layout"]);
}
if(cfg.has_attribute("title_alignment")) {
title_alignment_ = string_title_align(cfg["title_alignment"]);
}
if(cfg.has_attribute("music")) {
music_ = cfg["music"].str();
}
if(cfg.has_attribute("sound")) {
sound_ = cfg["sound"].str();
}
// Execution flow/branching/[image]
for(vconfig::all_children_iterator i = cfg.ordered_begin(); i != cfg.ordered_end(); ++ i) {
// i->first and i->second are goddamn temporaries; do not make references
const std::string key = i->first;
const vconfig node = i->second;
// [background_layer]
if (key == "background_layer") {
background_layers_.push_back(node.get_parsed_config());
}
// [image]
else if(key == "image") {
floating_images_.push_back(node.get_parsed_config());
}
// [if]
else if(key == "if") {
// check if the [if] tag has a [then] child;
// if we try to execute a non-existing [then], we get a segfault
if (game_events::conditional_passed(node)) {
if (node.has_child("then")) {
resolve_wml(node.child("then"));
}
}
// condition not passed, check [elseif] and [else]
else {
// get all [elseif] children and set a flag
vconfig::child_list elseif_children = node.get_children("elseif");
bool elseif_flag = false;
// for each [elseif]: test if it has a [then] child
// if the condition matches, execute [then] and raise flag
for (vconfig::child_list::const_iterator elseif = elseif_children.begin(); elseif != elseif_children.end(); ++elseif) {
if (game_events::conditional_passed(*elseif)) {
if (elseif->has_child("then")) {
resolve_wml(elseif->child("then"));
}
elseif_flag = true;
break;
}
}
// if we have an [else] tag and no [elseif] was successful (flag not raised), execute it
if (node.has_child("else") && !elseif_flag) {
resolve_wml(node.child("else"));
}
}
}
// [switch]
else if(key == "switch") {
const std::string var_name = node["variable"];
const std::string var_actual_value = resources::gamedata->get_variable_const(var_name);
bool case_not_found = true;
for(vconfig::all_children_iterator j = node.ordered_begin(); j != node.ordered_end(); ++j) {
if(j->first != "case") continue;
// Enter all matching cases.
const std::string var_expected_value = (j->second)["value"];
if(var_actual_value == var_expected_value) {
case_not_found = false;
resolve_wml(j->second);
}
}
if(case_not_found) {
for(vconfig::all_children_iterator j = node.ordered_begin(); j != node.ordered_end(); ++j) {
if(j->first != "else") continue;
// Enter all elses.
resolve_wml(j->second);
}
}
}
// [deprecated_message]
else if(key == "deprecated_message") {
// Won't appear until the scenario start event finishes.
lg::wml_error() << node["message"] << '\n';
}
// [wml_message]
else if(key == "wml_message") {
// As with [deprecated_message],
// it won't appear until the scenario start event is complete.
resources::game_events->pump().put_wml_message(node["logger"],node["message"],node["in_chat"]);
}
}
}
static std::shared_ptr<unit_filter_abstract_impl> construct(const vconfig & vcfg, const filter_context & fc, bool flat_tod)
{
if (vcfg.empty()) {
return std::make_shared<null_unit_filter_impl> (fc);
}
if (vcfg.get_config().attribute_count() == 1 && vcfg.get_config().all_children_count() == 0 && vcfg.has_attribute("limit")) {
return std::make_shared<null_unit_filter_impl> (fc);
}
return std::make_shared<basic_unit_filter_impl>(vcfg, fc, flat_tod);
//TODO: Add more efficient implementations for special cases
}
void part::resolve_wml(const vconfig &cfg)
{
if(cfg.null()) {
return;
}
if(cfg.has_attribute("background")) {
background_file_ = cfg["background"].str();
}
if(cfg.has_attribute("scale_background")) {
scale_background_ = cfg["scale_background"].to_bool(true);
}
if(cfg.has_attribute("show_title")) {
show_title_ = cfg["show_title"].to_bool();
}
if(cfg.has_attribute("story")) {
text_ = cfg["story"].str();
}
if(cfg.has_attribute("title")) {
text_title_ = cfg["title"].str();
if(!cfg.has_attribute("show_title")) {
show_title_ = true;
}
}
if(cfg.has_attribute("text_layout")) {
text_block_loc_ = string_tblock_loc(cfg["text_layout"]);
}
if(cfg.has_attribute("title_alignment")) {
title_alignment_ = string_title_align(cfg["title_alignment"]);
}
if(cfg.has_attribute("music")) {
music_ = cfg["music"].str();
}
if(cfg.has_attribute("sound")) {
sound_ = cfg["sound"].str();
}
// Execution flow/branching/[image]
for(vconfig::all_children_iterator i = cfg.ordered_begin(); i != cfg.ordered_end(); ++ i) {
// i->first and i->second are goddamn temporaries; do not make references
const std::string key = i->first;
const vconfig node = i->second;
// [image]
if(key == "image") {
floating_images_.push_back(node.get_parsed_config());
}
// [if]
else if(key == "if") {
const std::string branch_label =
game_events::conditional_passed(node) ?
"then" : "else";
if(node.has_child(branch_label)) {
const vconfig branch = node.child(branch_label);
resolve_wml(branch);
}
}
// [switch]
else if(key == "switch") {
const std::string var_name = node["variable"];
const std::string var_actual_value = resources::state_of_game->get_variable_const(var_name);
bool case_not_found = true;
for(vconfig::all_children_iterator j = node.ordered_begin(); j != node.ordered_end(); ++j) {
if(j->first != "case") continue;
// Enter all matching cases.
const std::string var_expected_value = (j->second)["value"];
if(var_actual_value == var_expected_value) {
case_not_found = false;
resolve_wml(j->second);
}
}
if(case_not_found) {
for(vconfig::all_children_iterator j = node.ordered_begin(); j != node.ordered_end(); ++j) {
if(j->first != "else") continue;
// Enter all elses.
resolve_wml(j->second);
}
}
}
// [deprecated_message]
else if(key == "deprecated_message") {
// Won't appear until the scenario start event finishes.
game_events::handle_deprecated_message(node.get_parsed_config());
}
// [wml_message]
else if(key == "wml_message") {
// Pass to game events handler. As with [deprecated_message],
// it won't appear until the scenario start event is complete.
game_events::handle_wml_log_message(node.get_parsed_config());
}
}
}
