bool config::matches(const config &filter) const { check_valid(filter); for (const attribute &i : filter.attribute_range()) { const attribute_value *v = get(i.first); if (!v || *v != i.second) return false; } for (const any_child &i : filter.all_children_range()) { if (i.key == "not") { if (matches(i.cfg)) return false; continue; } bool found = false; for (const config &j : child_range(i.key)) { if (j.matches(i.cfg)) { found = true; break; } } if(!found) return false; } return true; }
/** * Merges the given config over the existing costs. * @param[in] new_values The new values. * @param[in] overwrite If true, the new values overwrite the old. * If false, the new values are added to the old. * @param[in] cascade Cache clearing will be cascaded into this terrain_info. */ void movetype::terrain_info::data::merge(const config & new_values, bool overwrite, const terrain_info * cascade) { if ( overwrite ) // We do not support child tags here, so do not copy any that might // be in the input. (If in the future we need to support child tags, // change "merge_attributes" to "merge_with".) cfg_.merge_attributes(new_values); else { for (const config::attribute & a : new_values.attribute_range()) { config::attribute_value & dest = cfg_[a.first]; int old = dest.to_int(params_.max_value); // The new value is the absolute value of the old plus the // provided value, capped between minimum and maximum, then // given the sign of the old value. // (Think defenses for why we might have negative values.) int value = abs(old) + a.second.to_int(0); value = std::max(params_.min_value, std::min(value, params_.max_value)); if ( old < 0 ) value = -value; dest = value; } } // The new data has invalidated the cache. clear_cache(cascade); }
/** * Tests if merging @a new_values would result in changes. * This allows the shared data to actually work, as otherwise each unit created * via WML (including unstored units) would "overwrite" its movement data with * a usually identical copy and thus break the sharing. */ bool movetype::terrain_info::data::config_has_changes(const config & new_values, bool overwrite) const { if ( overwrite ) { for (const config::attribute & a : new_values.attribute_range()) if ( a.second != cfg_[a.first] ) return true; } else { for (const config::attribute & a : new_values.attribute_range()) if ( a.second.to_int() != 0 ) return true; } // If we make it here, new_values has no changes for us. return false; }
/** * Tests if merging @a new_values would result in changes. * This allows the shared data to actually work, as otherwise each unit created * via WML (including unstored units) would "overwrite" its movement data with * a usually identical copy and thus break the sharing. */ bool movetype::terrain_info::data::config_has_changes(const config & new_values, bool overwrite) const { if ( overwrite ) { BOOST_FOREACH( const config::attribute & a, new_values.attribute_range() ) if ( a.second != cfg_[a.first] ) return true; } else {
static stats::str_int_map read_str_int_map(const config& cfg) { stats::str_int_map m; BOOST_FOREACH(const config::attribute &i, cfg.attribute_range()) { m[i.first] = i.second; } return m; }
/** * Merges the given config over the existing costs. * If @a overwrite is false, the new values will be added to the old. */ void movetype::resistances::merge(const config & new_data, bool overwrite) { if ( overwrite ) // We do not support child tags here, so do not copy any that might // be in the input. (If in the future we need to support child tags, // change "merge_attributes" to "merge_with".) cfg_.merge_attributes(new_data); else for (const config::attribute & a : new_data.attribute_range()) { config::attribute_value & dest = cfg_[a.first]; dest = std::max(0, dest.to_int(100) + a.second.to_int(0)); } }
static void write_internal(config const &cfg, std::ostream &out, std::string& textdomain, size_t tab = 0) { if (tab > max_recursion_levels) throw config::error("Too many recursion levels in config write"); foreach (const config::attribute &i, cfg.attribute_range()) { write_key_val(out, i.first, i.second, tab, textdomain); } foreach (const config::any_child &item, cfg.all_children_range()) { write_open_child(out, item.key, tab); write_internal(item.cfg, out, textdomain, tab + 1); write_close_child(out, item.key, tab); } }
void luaW_filltable(lua_State *L, config const &cfg) { if (!lua_checkstack(L, LUA_MINSTACK)) return; int k = 1; for (const config::any_child &ch : cfg.all_children_range()) { lua_createtable(L, 2, 0); lua_pushstring(L, ch.key.c_str()); lua_rawseti(L, -2, 1); lua_newtable(L); luaW_filltable(L, ch.cfg); lua_rawseti(L, -2, 2); lua_rawseti(L, -2, k++); } for (const config::attribute &attr : cfg.attribute_range()) { luaW_pushscalar(L, attr.second); lua_setfield(L, -2, attr.first.c_str()); } }
static void write_internal(config const &cfg, std::ostream &out, std::string& textdomain, size_t tab = 0) { if (tab > max_recursion_levels) throw config::error("Too many recursion levels in config write"); for (const config::attribute &i : cfg.attribute_range()) { if (!config::valid_id(i.first)) { ERR_CF << "Config contains invalid attribute name '" << i.first << "', skipping...\n"; continue; } write_key_val(out, i.first, i.second, tab, textdomain); } for (const config::any_child &item : cfg.all_children_range()) { if (!config::valid_id(item.key)) { ERR_CF << "Config contains invalid tag name '" << item.key << "', skipping...\n"; continue; } write_open_child(out, item.key, tab); write_internal(item.cfg, out, textdomain, tab + 1); write_close_child(out, item.key, tab); } }
turn_info::PROCESS_DATA_RESULT turn_info::process_network_data(const config& cfg) { // the simple wesnothserver implementation in wesnoth was removed years ago. assert(cfg.all_children_count() == 1); assert(cfg.attribute_range().first == cfg.attribute_range().second); if(!resources::recorder->at_end()) { ERR_NW << "processing network data while still having data on the replay." << std::endl; } if (const config &msg = cfg.child("message")) { resources::screen->get_chat_manager().add_chat_message(time(nullptr), msg["sender"], msg["side"], msg["message"], events::chat_handler::MESSAGE_PUBLIC, preferences::message_bell()); } else if (const config &msg = cfg.child("whisper") /*&& is_observer()*/) { resources::screen->get_chat_manager().add_chat_message(time(nullptr), "whisper: " + msg["sender"].str(), 0, msg["message"], events::chat_handler::MESSAGE_PRIVATE, preferences::message_bell()); } else if (const config &ob = cfg.child("observer") ) { resources::screen->get_chat_manager().add_observer(ob["name"]); } else if (const config &ob = cfg.child("observer_quit")) { resources::screen->get_chat_manager().remove_observer(ob["name"]); } else if (cfg.child("leave_game")) { throw ingame_wesnothd_error(""); } else if (const config &turn = cfg.child("turn")) { return handle_turn(turn); } else if (cfg.has_child("whiteboard")) { resources::whiteboard->process_network_data(cfg); } else if (const config &change = cfg.child("change_controller")) { if(change.empty()) { ERR_NW << "Bad [change_controller] signal from server, [change_controller] tag was empty." << std::endl; return PROCESS_CONTINUE; } const int side = change["side"].to_int(); const bool is_local = change["is_local"].to_bool(); const std::string player = change["player"]; const size_t index = side - 1; if(index >= resources::gameboard->teams().size()) { ERR_NW << "Bad [change_controller] signal from server, side out of bounds: " << change.debug() << std::endl; return PROCESS_CONTINUE; } const team & tm = resources::gameboard->teams().at(index); const bool was_local = tm.is_local(); resources::gameboard->side_change_controller(side, is_local, player); if (!was_local && tm.is_local()) { resources::controller->on_not_observer(); } if (resources::gameboard->is_observer() || (resources::gameboard->teams())[resources::screen->playing_team()].is_local_human()) { resources::screen->set_team(resources::screen->playing_team()); resources::screen->redraw_everything(); resources::screen->recalculate_minimap(); } else if (tm.is_local_human()) { resources::screen->set_team(side - 1); resources::screen->redraw_everything(); resources::screen->recalculate_minimap(); } resources::whiteboard->on_change_controller(side,tm); resources::screen->labels().recalculate_labels(); const bool restart = resources::screen->playing_side() == side && (was_local || tm.is_local()); return restart ? PROCESS_RESTART_TURN : PROCESS_CONTINUE; } else if (const config &side_drop_c = cfg.child("side_drop")) { const int side_drop = side_drop_c["side_num"].to_int(0); size_t index = side_drop -1; bool restart = side_drop == resources::screen->playing_side(); if (index >= resources::teams->size()) { ERR_NW << "unknown side " << side_drop << " is dropping game" << std::endl; throw ingame_wesnothd_error(""); } team::CONTROLLER ctrl; if(!ctrl.parse(side_drop_c["controller"])) { ERR_NW << "unknown controller type issued from server on side drop: " << side_drop_c["controller"] << std::endl; throw ingame_wesnothd_error(""); } if (ctrl == team::CONTROLLER::AI) { resources::gameboard->side_drop_to(side_drop, ctrl); return restart ? PROCESS_RESTART_TURN:PROCESS_CONTINUE; } //null controlled side cannot be dropped becasue they aren't controlled by anyone. else if (ctrl != team::CONTROLLER::HUMAN) { ERR_NW << "unknown controller type issued from server on side drop: " << ctrl.to_cstring() << std::endl; throw ingame_wesnothd_error(""); } int action = 0; int first_observer_option_idx = 0; int control_change_options = 0; bool has_next_scenario = !resources::gamedata->next_scenario().empty() && resources::gamedata->next_scenario() != "null"; std::vector<std::string> observers; std::vector<const team *> allies; std::vector<std::string> options; const team &tm = resources::gameboard->teams()[index]; for (const team &t : resources::gameboard->teams()) { if (!t.is_enemy(side_drop) && !t.is_local_human() && !t.is_local_ai() && !t.is_network_ai() && !t.is_empty() && t.current_player() != tm.current_player()) { allies.push_back(&t); } } // We want to give host chance to decide what to do for side if (!resources::controller->is_linger_mode() || has_next_scenario) { utils::string_map t_vars; //get all allies in as options to transfer control for (const team *t : allies) { //if this is an ally of the dropping side and it is not us (choose local player //if you want that) and not ai or empty and if it is not the dropping side itself, //get this team in as well t_vars["player"] = t->current_player(); options.push_back(vgettext("Give control to their ally $player", t_vars)); control_change_options++; } first_observer_option_idx = options.size(); //get all observers in as options to transfer control for (const std::string &ob : resources::screen->observers()) { t_vars["player"] = ob; options.push_back(vgettext("Give control to observer $player", t_vars)); observers.push_back(ob); control_change_options++; } options.push_back(_("Replace with AI")); options.push_back(_("Replace with local player")); options.push_back(_("Set side to idle")); options.push_back(_("Save and abort game")); t_vars["player"] = tm.current_player(); const std::string msg = vgettext("$player has left the game. What do you want to do?", t_vars); gui2::tsimple_item_selector dlg("", msg, options); dlg.set_single_button(true); dlg.show(resources::screen->video()); action = dlg.selected_index(); // If esc was pressed, default to setting side to idle if (action == -1) { action = control_change_options + 2; } } else { // Always set leaving side to idle if in linger mode and there is no next scenario action = 2; } if (action < control_change_options) { // Grant control to selected ally { // Server thinks this side is ours now so in case of error transferring side we have to make local state to same as what server thinks it is. resources::gameboard->side_drop_to(side_drop, team::CONTROLLER::HUMAN, team::PROXY_CONTROLLER::PROXY_IDLE); } if (action < first_observer_option_idx) { change_side_controller(side_drop, allies[action]->current_player()); } else { change_side_controller(side_drop, observers[action - first_observer_option_idx]); } return restart ? PROCESS_RESTART_TURN : PROCESS_CONTINUE; } else { action -= control_change_options; //make the player an AI, and redo this turn, in case //it was the current player's team who has just changed into //an AI. switch(action) { case 0: resources::controller->on_not_observer(); resources::gameboard->side_drop_to(side_drop, team::CONTROLLER::HUMAN, team::PROXY_CONTROLLER::PROXY_AI); return restart?PROCESS_RESTART_TURN:PROCESS_CONTINUE; case 1: resources::controller->on_not_observer(); resources::gameboard->side_drop_to(side_drop, team::CONTROLLER::HUMAN, team::PROXY_CONTROLLER::PROXY_HUMAN); return restart?PROCESS_RESTART_TURN:PROCESS_CONTINUE; case 2: resources::gameboard->side_drop_to(side_drop, team::CONTROLLER::HUMAN, team::PROXY_CONTROLLER::PROXY_IDLE); return restart?PROCESS_RESTART_TURN:PROCESS_CONTINUE; case 3: //The user pressed "end game". Don't throw a network error here or he will get //thrown back to the title screen. do_save(); throw_quit_game_exception(); default: break; } } } // The host has ended linger mode in a campaign -> enable the "End scenario" button // and tell we did get the notification. else if (cfg.child("notify_next_scenario")) { gui::button* btn_end = resources::screen->find_action_button("button-endturn"); if(btn_end) { btn_end->enable(true); } return PROCESS_END_LINGER; } //If this client becomes the new host, notify the play_controller object about it else if (cfg.child("host_transfer")){ host_transfer_.notify_observers(); } else { ERR_NW << "found unknown command:\n" << cfg.debug() << std::endl; } return PROCESS_CONTINUE; }