The Battle for Wesnoth  1.17.12+dev
mp_create_game.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2008 - 2022
3  by Mark de Wever <koraq@xs4all.nl>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 #define GETTEXT_DOMAIN "wesnoth-lib"
17 
19 
20 #include "filesystem.hpp"
21 #include "formatter.hpp"
22 #include "formula/string_utils.hpp"
23 #include "game_config.hpp"
24 #include "game_config_manager.hpp"
26 #include "gettext.hpp"
27 #include "gui/auxiliary/field.hpp"
28 #include "gui/dialogs/message.hpp"
31 #include "gui/widgets/button.hpp"
32 #include "gui/widgets/image.hpp"
34 #include "gui/widgets/listbox.hpp"
36 #include "gui/widgets/minimap.hpp"
37 #include "gui/widgets/slider.hpp"
40 #include "gui/widgets/text_box.hpp"
43 #include "log.hpp"
44 #include "map_settings.hpp"
45 #include "preferences/game.hpp"
46 #include "save_index.hpp"
47 #include "savegame.hpp"
48 
49 #include <boost/algorithm/string.hpp>
50 
51 static lg::log_domain log_mp_create("mp/create");
52 
53 #define DBG_MP LOG_STREAM(debug, log_mp_create)
54 #define WRN_MP LOG_STREAM(warn, log_mp_create)
55 #define ERR_MP LOG_STREAM(err, log_mp_create)
56 
57 namespace gui2::dialogs
58 {
59 
60 // Special retval value for loading a game
61 static const int LOAD_GAME = 100;
62 
63 // Shorthand
64 namespace prefs = preferences;
65 
67 
68 mp_create_game::mp_create_game(saved_game& state, bool local_mode)
69  : modal_dialog(window_id())
70  , create_engine_(state)
71  , config_engine_()
72  , options_manager_()
73  , selected_game_index_(-1)
74  , selected_rfm_index_(-1)
75  , use_map_settings_(register_bool( "use_map_settings", true, prefs::use_map_settings, prefs::set_use_map_settings,
76  std::bind(&mp_create_game::update_map_settings, this)))
77  , fog_(register_bool("fog", true, prefs::fog, prefs::set_fog))
78  , shroud_(register_bool("shroud", true, prefs::shroud, prefs::set_shroud))
79  , start_time_(register_bool("random_start_time", true, prefs::random_start_time, prefs::set_random_start_time))
80  , time_limit_(register_bool("time_limit", true, prefs::countdown, prefs::set_countdown,
81  std::bind(&mp_create_game::update_map_settings, this)))
82  , shuffle_sides_(register_bool("shuffle_sides", true, prefs::shuffle_sides, prefs::set_shuffle_sides))
83  , observers_(register_bool("observers", true, prefs::allow_observers, prefs::set_allow_observers))
84  , strict_sync_(register_bool("strict_sync", true))
85  , private_replay_(register_bool("private_replay", true))
86  , turns_(register_integer("turn_count", true, prefs::turns, prefs::set_turns))
87  , gold_(register_integer("village_gold", true, prefs::village_gold, prefs::set_village_gold))
88  , support_(register_integer("village_support", true, prefs::village_support, prefs::set_village_support))
89  , experience_(register_integer("experience_modifier", true, prefs::xp_modifier, prefs::set_xp_modifier))
90  , init_turn_limit_(register_integer("init_turn_limit", true, prefs::countdown_init_time, prefs::set_countdown_init_time))
91  , turn_bonus_(register_integer("turn_bonus", true, prefs::countdown_turn_bonus, prefs::set_countdown_turn_bonus))
92  , reservoir_(register_integer("reservoir", true, prefs::countdown_reservoir_time, prefs::set_countdown_reservoir_time))
93  , action_bonus_(register_integer("action_bonus", true, prefs::countdown_action_bonus, prefs::set_countdown_action_bonus))
94  , mod_list_()
95  , eras_menu_button_()
96  , local_mode_(local_mode)
97 {
98  level_types_ = {
99  {level_type::type::scenario, _("Scenarios")},
100  {level_type::type::campaign, _("Multiplayer Campaigns")},
101  {level_type::type::sp_campaign, _("Singleplayer Campaigns")},
102  {level_type::type::user_map, _("Custom Maps")},
103  {level_type::type::user_scenario, _("Custom Scenarios")},
104  {level_type::type::random_map, _("Random Maps")},
105  };
106 
107  level_types_.erase(std::remove_if(level_types_.begin(), level_types_.end(),
108  [this](level_type_info& type_info) {
109  return create_engine_.get_levels_by_type_unfiltered(type_info.first).empty();
110  }), level_types_.end());
111 
112  set_show_even_without_video(true);
113 
114  create_engine_.init_active_mods();
115 
116  create_engine_.get_state().clear();
117  create_engine_.get_state().classification().type = campaign_type::type::multiplayer;
118 
119  // Need to set this in the constructor, pre_show() is too late
120  set_allow_plugin_skip(false);
121 }
122 
124 {
125  find_widget<text_box>(&win, "game_name", false).set_value(local_mode_ ? "" : ng::configure_engine::game_name_default());
126 
128  find_widget<button>(&win, "random_map_regenerate", false),
129  std::bind(&mp_create_game::regenerate_random_map, this));
130 
132  find_widget<button>(&win, "random_map_settings", false),
133  std::bind(&mp_create_game::show_generator_settings, this));
134 
136  find_widget<button>(&win, "load_game", false),
137  std::bind(&mp_create_game::load_game_callback, this));
138 
139  // Custom dialog close hook
140  win.set_exit_hook(window::exit_hook::on_ok, [this](window& w) { return dialog_exit_hook(w); });
141 
142  //
143  // Set up the options manager. Needs to be done before selecting an initial tab
144  //
146 
147  //
148  // Set up filtering
149  //
150  connect_signal_notify_modified(find_widget<slider>(&win, "num_players", false),
151  std::bind(&mp_create_game::on_filter_change<slider>, this, "num_players", true));
152 
153  text_box& filter = find_widget<text_box>(&win, "game_filter", false);
154 
156  std::bind(&mp_create_game::on_filter_change<text_box>, this, "game_filter", true));
157 
158  // Note this cannot be in the keyboard chain or it will capture focus from other text boxes
159  win.keyboard_capture(&filter);
160 
161  //
162  // Set up game types menu_button
163  //
164  std::vector<config> game_types;
165  for(level_type_info& type_info : level_types_) {
166  game_types.emplace_back("label", type_info.second);
167  }
168 
169  if(game_types.empty()) {
170  gui2::show_transient_message("", _("No games found."));
171  throw game::error(_("No games found."));
172  }
173 
174  menu_button& game_menu_button = find_widget<menu_button>(&win, "game_types", false);
175 
176  // Helper to make sure the initially selected level type is valid
177  auto get_initial_type_index = [this]()->int {
178  const auto index = std::find_if(level_types_.begin(), level_types_.end(), [](level_type_info& info) {
180  });
181 
182  if(index != level_types_.end()) {
183  return std::distance(level_types_.begin(), index);
184  }
185 
186  return 0;
187  };
188 
189  game_menu_button.set_values(game_types, get_initial_type_index());
190 
191  connect_signal_notify_modified(game_menu_button,
192  std::bind(&mp_create_game::update_games_list, this));
193 
194  //
195  // Set up mods list
196  //
197  mod_list_ = &find_widget<listbox>(&win, "mod_list", false);
198 
199  const auto& activemods = preferences::modifications();
203 
204  item["label"] = mod->name;
205  data.emplace("mod_name", item);
206 
207  grid* row_grid = &mod_list_->add_row(data);
208 
209  find_widget<toggle_panel>(row_grid, "panel", false).set_tooltip(mod->description);
210 
211  toggle_button& mog_toggle = find_widget<toggle_button>(row_grid, "mod_active_state", false);
212 
213  const int i = mod_list_->get_item_count() - 1;
214  if(std::find(activemods.begin(), activemods.end(), mod->id) != activemods.end()) {
215  create_engine_.active_mods().push_back(mod->id);
216  mog_toggle.set_value_bool(true);
217  }
218 
219  connect_signal_notify_modified(mog_toggle, std::bind(&mp_create_game::on_mod_toggle, this, i, &mog_toggle));
220  }
221 
222  // No mods, hide the header
223  if(mod_list_->get_item_count() <= 0) {
224  find_widget<styled_widget>(&win, "mods_header", false).set_visible(widget::visibility::invisible);
225  }
226 
227  //
228  // Set up eras menu_button
229  //
230  eras_menu_button_ = &find_widget<menu_button>(&win, "eras", false);
231 
232  std::vector<config> era_names;
234  era_names.emplace_back("label", era->name, "tooltip", era->description);
235  }
236 
237  if(era_names.empty()) {
238  gui2::show_transient_message("", _("No eras found."));
239  throw config::error(_("No eras found"));
240  }
241 
242  eras_menu_button_->set_values(era_names);
243 
245  std::bind(&mp_create_game::on_era_select, this));
246 
248  if(era_selection >= 0) {
249  eras_menu_button_->set_selected(era_selection);
250  }
251 
252  on_era_select();
253 
254  //
255  // Set up random faction mode menu_button
256  //
257  const int initial_index = static_cast<int>(random_faction_mode::get_enum(prefs::random_faction_mode()).value_or(random_faction_mode::type::independent));
258 
259  menu_button& rfm_menu_button = find_widget<menu_button>(&win, "random_faction_mode", false);
260  rfm_menu_button.set_selected(initial_index);
261 
262  connect_signal_notify_modified(rfm_menu_button,
264 
266 
267  //
268  // Set up the setting status labels
269  //
270  bind_status_label<slider>(&win, turns_->id());
271  bind_status_label<slider>(&win, gold_->id());
272  bind_status_label<slider>(&win, support_->id());
273  bind_status_label<slider>(&win, experience_->id());
274 
275  bind_status_label<slider>(&win, init_turn_limit_->id());
276  bind_status_label<slider>(&win, turn_bonus_->id());
277  bind_status_label<slider>(&win, reservoir_->id());
278  bind_status_label<slider>(&win, action_bonus_->id());
279 
280  //
281  // Timer reset button
282  //
284  find_widget<button>(&win, "reset_timer_defaults", false),
285  std::bind(&mp_create_game::reset_timer_settings, this));
286 
287  //
288  // Disable certain settings if we're playing a local game.
289  //
290  if(local_mode_) {
291  find_widget<text_box>(&win, "game_name", false).set_active(false);
292  find_widget<text_box>(&win, "game_password", false).set_active(false);
293 
294  observers_->widget_set_enabled(false, false);
295  strict_sync_->widget_set_enabled(false, false);
296  private_replay_->widget_set_enabled(false, false);
297  }
298 
299  //
300  // Set up tab control
301  //
302  listbox& tab_bar = find_widget<listbox>(&win, "tab_bar", false);
303 
305  std::bind(&mp_create_game::on_tab_select, this));
306 
307  // Allow the settings stack to find widgets in all pages, regardless of which is selected.
308  // This ensures settings (especially game settings) widgets are appropriately updated when
309  // a new game is selected, regardless of which settings tab is active at the time.
310  find_widget<stacked_widget>(&win, "pager", false).set_find_in_all_layers(true);
311 
312  // We call on_tab_select farther down.
313 
314  //
315  // Main games list
316  //
317  listbox& list = find_widget<listbox>(&win, "games_list", false);
318 
320  std::bind(&mp_create_game::on_game_select, this));
321 
322  win.add_to_keyboard_chain(&list);
323 
324  // This handles the initial game selection as well
325  display_games_of_type(level_types_[get_initial_type_index()].first, preferences::level());
326 
327  // Initial tab selection must be done after game selection so the field widgets are set to their correct active state.
328  on_tab_select();
329 
330  //
331  // Set up the Lua plugin context
332  //
333  plugins_context_.reset(new plugins_context("Multiplayer Create"));
334 
335  plugins_context_->set_callback("create", [&win](const config&) { win.set_retval(retval::OK); }, false);
336  plugins_context_->set_callback("quit", [&win](const config&) { win.set_retval(retval::CANCEL); }, false);
337  plugins_context_->set_callback("load", [this](const config&) { load_game_callback(); }, false);
338 
339 #define UPDATE_ATTRIBUTE(field, convert) \
340  do { if(cfg.has_attribute(#field)) { field##_->set_widget_value(cfg[#field].convert()); } } while(false) \
341 
342  plugins_context_->set_callback("update_settings", [this](const config& cfg) {
343  UPDATE_ATTRIBUTE(turns, to_int);
344  UPDATE_ATTRIBUTE(gold, to_int);
345  UPDATE_ATTRIBUTE(support, to_int);
346  UPDATE_ATTRIBUTE(experience, to_int);
347  UPDATE_ATTRIBUTE(start_time, to_bool);
348  UPDATE_ATTRIBUTE(fog, to_bool);
349  UPDATE_ATTRIBUTE(shroud, to_bool);
350  UPDATE_ATTRIBUTE(time_limit, to_bool);
351  UPDATE_ATTRIBUTE(init_turn_limit, to_int);
352  UPDATE_ATTRIBUTE(turn_bonus, to_int);
353  UPDATE_ATTRIBUTE(reservoir, to_int);
354  UPDATE_ATTRIBUTE(action_bonus, to_int);
355  UPDATE_ATTRIBUTE(observers, to_bool);
356  UPDATE_ATTRIBUTE(strict_sync, to_bool);
357  UPDATE_ATTRIBUTE(private_replay, to_bool);
359  }, true);
360 
361 #undef UPDATE_ATTRIBUTE
362 
363  plugins_context_->set_callback("set_name", [this](const config& cfg) {
364  config_engine_->set_game_name(cfg["name"]); }, true);
365 
366  plugins_context_->set_callback("set_password", [this](const config& cfg) {
367  config_engine_->set_game_password(cfg["password"]); }, true);
368 
369  plugins_context_->set_callback("select_level", [this](const config& cfg) {
370  selected_game_index_ = convert_to_game_filtered_index(cfg["index"].to_int());
372  }, true);
373 
374  plugins_context_->set_callback("select_type", [this](const config& cfg) {
375  create_engine_.set_current_level_type(level_type::get_enum(cfg["type"].str()).value_or(level_type::type::scenario)); }, true);
376 
377  plugins_context_->set_callback("select_era", [this](const config& cfg) {
378  create_engine_.set_current_era_index(cfg["index"].to_int()); }, true);
379 
380  plugins_context_->set_callback("select_mod", [this](const config& cfg) {
381  on_mod_toggle(cfg["index"].to_int(), nullptr);
382  }, true);
383 
384  plugins_context_->set_accessor("get_selected", [this](const config&) {
385  const ng::level& current_level = create_engine_.current_level();
386  return config {
387  "id", current_level.id(),
388  "name", current_level.name(),
389  "icon", current_level.icon(),
390  "description", current_level.description(),
391  "allow_era_choice", current_level.allow_era_choice(),
393  };
394  });
395 
396  plugins_context_->set_accessor("find_level", [this](const config& cfg) {
397  const std::string id = cfg["id"].str();
398  return config {
399  "index", create_engine_.find_level_by_id(id).second,
401  };
402  });
403 
404  plugins_context_->set_accessor_int("find_era", [this](const config& cfg) {
406  });
407 
408  plugins_context_->set_accessor_int("find_mod", [this](const config& cfg) {
410  });
411 }
412 
414 {
415  DBG_MP << "sync_with_depcheck: start";
416 
418  DBG_MP << "sync_with_depcheck: correcting era";
419  const int new_era_index = create_engine_.dependency_manager().get_era_index();
420 
421  create_engine_.set_current_era_index(new_era_index, true);
422  eras_menu_button_->set_value(new_era_index);
423  }
424 
426  DBG_MP << "sync_with_depcheck: correcting scenario";
427 
428  // Match scenario and scenario type
430  const bool different_type = new_level_index.first != create_engine_.current_level_type();
431 
432  if(new_level_index.second != -1) {
433  create_engine_.set_current_level_type(new_level_index.first);
434  create_engine_.set_current_level(new_level_index.second);
435  selected_game_index_ = new_level_index.second;
436 
437  auto& game_types_list = find_widget<menu_button>(get_window(), "game_types", false);
438  game_types_list.set_value(std::distance(level_types_.begin(), std::find_if(level_types_.begin(), level_types_.begin(), [&](const level_type_info& info){ return info.first == new_level_index.first; })));
439 
440  if(different_type) {
441  display_games_of_type(new_level_index.first, create_engine_.current_level().id());
442  } else {
443  // This function (or rather on_game_select) might be triggered by a listbox callback, in
444  // which case we cannot use display_games_of_type since it destroys the list (and its
445  // elements) which might result in segfaults. Instead, we assume that a listbox-triggered
446  // sync_with_depcheck call never changes the game type and goes to this branch instead.
447  find_widget<listbox>(get_window(), "games_list", false).select_row(new_level_index.second);
448 
449  // Override the last selection so on_game_select selects the new level
451 
452  on_game_select();
453  }
454  }
455  }
456 
458  DBG_MP << "sync_with_depcheck: correcting modifications";
460  }
461 
463  DBG_MP << "sync_with_depcheck: end";
464 }
465 
466 template<typename T>
467 void mp_create_game::on_filter_change(const std::string& id, bool do_select)
468 {
469  create_engine_.apply_level_filter(find_widget<T>(get_window(), id, false).get_value());
470 
471  listbox& game_list = find_widget<listbox>(get_window(), "games_list", false);
472 
473  boost::dynamic_bitset<> filtered(game_list.get_item_count());
475  filtered[i] = true;
476  }
477 
478  game_list.set_row_shown(filtered);
479 
480  if(do_select) {
481  on_game_select();
482  }
483 }
484 
486 {
487  const int selected_game = find_widget<listbox>(get_window(), "games_list", false).get_selected_row();
488 
489  if(selected_game == selected_game_index_) {
490  return;
491  }
492 
493  // Convert the absolute-index get_selected_row to a relative index for the create_engine to handle
495 
497 
499 
500  update_details();
501 
502  // General settings
503  const bool can_select_era = create_engine_.current_level().allow_era_choice();
504 
505  if(!can_select_era) {
506  eras_menu_button_->set_label(_("No eras available for this game."));
507  } else {
509  }
510 
511  eras_menu_button_->set_active(can_select_era);
512 
513  // Custom options
514  options_manager_->update_game_options();
515 
516  // Game settings
518 }
519 
521 {
522  const int i = find_widget<listbox>(get_window(), "tab_bar", false).get_selected_row();
523  find_widget<stacked_widget>(get_window(), "pager", false).select_layer(i);
524 }
525 
527 {
528  if(sender && (sender->get_value_bool() == create_engine_.dependency_manager().is_modification_active(index))) {
529  ERR_MP << "ignoring on_mod_toggle that is already set";
530  return;
531  }
532 
533  create_engine_.toggle_mod(index);
534 
536 
537  options_manager_->update_mod_options();
538 }
539 
541 {
543 
545 
547 
548  options_manager_->update_era_options();
549 }
550 
552 {
553  selected_rfm_index_ = find_widget<menu_button>(get_window(), "random_faction_mode", false).get_value();
554 }
555 
556 void mp_create_game::show_description(const std::string& new_description)
557 {
558  styled_widget& description = find_widget<styled_widget>(get_window(), "description", false);
559 
560  description.set_label(!new_description.empty() ? new_description : _("No description available."));
561  description.set_use_markup(true);
562 }
563 
565 {
566  const int index = find_widget<menu_button>(get_window(), "game_types", false).get_value();
567 
569 }
570 
572 {
574 
575  listbox& list = find_widget<listbox>(get_window(), "games_list", false);
576 
577  list.clear();
578 
579  for(const auto& game : create_engine_.get_levels_by_type_unfiltered(type)) {
582 
583  if(type == level_type::type::campaign || type == level_type::type::sp_campaign) {
584  item["label"] = game->icon();
585  data.emplace("game_icon", item);
586  }
587 
588  item["label"] = game->name();
589  data.emplace("game_name", item);
590 
591  list.add_row(data);
592  }
593 
594  if(!level.empty() && !list.get_rows_shown().empty()) {
595  // Recalculate which rows should be visible
596  on_filter_change<slider>("num_players", false);
597  on_filter_change<text_box>("game_filter", false);
598 
599  int level_index = create_engine_.find_level_by_id(level).second;
600  if(level_index >= 0 && std::size_t(level_index) < list.get_item_count()) {
601  list.select_row(level_index);
602  }
603  }
604 
605  const bool is_random_map = type == level_type::type::random_map;
606 
607  find_widget<button>(get_window(), "random_map_regenerate", false).set_active(is_random_map);
608  find_widget<button>(get_window(), "random_map_settings", false).set_active(is_random_map);
609 
610  // Override the last selection so on_game_select selects the new level
612 
613  on_game_select();
614 }
615 
617 {
619 
621 }
622 
624 {
626 
627  update_details();
628 }
629 
630 int mp_create_game::convert_to_game_filtered_index(const unsigned int initial_index)
631 {
632  const std::vector<std::size_t>& filtered_indices = create_engine_.get_filtered_level_indices(create_engine_.current_level_type());
633  return std::distance(filtered_indices.begin(), std::find(filtered_indices.begin(), filtered_indices.end(), initial_index));
634 }
635 
637 {
638  styled_widget& players = find_widget<styled_widget>(get_window(), "map_num_players", false);
639  styled_widget& map_size = find_widget<styled_widget>(get_window(), "map_size", false);
640 
641  if(create_engine_.current_level_type() == level_type::type::random_map) {
642  // If the current random map doesn't have data, generate it
644  create_engine_.current_level().data()["map_data"].empty() &&
645  create_engine_.current_level().data()["map_file"].empty()) {
647  }
648 
649  find_widget<button>(get_window(), "random_map_settings", false).set_active(create_engine_.generator_has_settings());
650  }
651 
653 
654  // Reset the config_engine with new values
656  config_engine_->update_initial_cfg(create_engine_.current_level().data());
657  config_engine_->set_default_values();
658 
659  // Set the title, with newlines replaced. Newlines are sometimes found in SP Campaign names
660  std::string title = create_engine_.current_level().name();
661  boost::replace_all(title, "\n", " " + font::unicode_em_dash + " ");
662  find_widget<styled_widget>(get_window(), "game_title", false).set_label(title);
663 
664 
666  case level_type::type::scenario:
667  case level_type::type::user_map:
668  case level_type::type::user_scenario:
669  case level_type::type::random_map: {
670  ng::scenario* current_scenario = dynamic_cast<ng::scenario*>(&create_engine_.current_level());
671 
672  assert(current_scenario);
673 
675 
676  find_widget<stacked_widget>(get_window(), "minimap_stack", false).select_layer(0);
677 
678  if(current_scenario->data()["map_data"].empty()) {
679  saved_game::expand_map_file(current_scenario->data());
680  current_scenario->set_metadata();
681  }
682 
683  find_widget<minimap>(get_window(), "minimap", false).set_map_data(current_scenario->data()["map_data"]);
684 
685  players.set_label(std::to_string(current_scenario->num_players()));
686  map_size.set_label(current_scenario->map_size());
687 
688  break;
689  }
690  case level_type::type::campaign:
691  case level_type::type::sp_campaign: {
692  ng::campaign* current_campaign = dynamic_cast<ng::campaign*>(&create_engine_.current_level());
693 
694  assert(current_campaign);
695 
696  create_engine_.get_state().classification().campaign = current_campaign->data()["id"].str();
697 
698  const std::string img = formatter() << current_campaign->data()["image"] << "~SCALE_INTO(265,265)";
699 
700  find_widget<stacked_widget>(get_window(), "minimap_stack", false).select_layer(1);
701  find_widget<image>(get_window(), "campaign_image", false).set_image(img);
702 
703  const int p_min = current_campaign->min_players();
704  const int p_max = current_campaign->max_players();
705 
706  if(p_max > p_min) {
707  players.set_label(VGETTEXT("number of players^$min to $max", {{"min", std::to_string(p_min)}, {"max", std::to_string(p_max)}}));
708  } else {
709  players.set_label(std::to_string(p_min));
710  }
711 
712  map_size.set_label(font::unicode_em_dash);
713 
714  break;
715  }
716  }
717 
718  // This needs to be at the end, since errors found expanding the map data are put into the description
720 }
721 
723 {
724  if(config_engine_->force_lock_settings()) {
725  use_map_settings_->widget_set_enabled(false, false);
727  } else {
729  }
730 
732 
733  config_engine_->set_use_map_settings(use_map_settings);
734 
735  fog_ ->widget_set_enabled(!use_map_settings, false);
736  shroud_ ->widget_set_enabled(!use_map_settings, false);
737  start_time_ ->widget_set_enabled(!use_map_settings, false);
738 
739  turns_ ->widget_set_enabled(!use_map_settings, false);
740  gold_ ->widget_set_enabled(!use_map_settings, false);
741  support_ ->widget_set_enabled(!use_map_settings, false);
742  experience_ ->widget_set_enabled(!use_map_settings, false);
743 
744  const bool time_limit = time_limit_->get_widget_value();
745 
746  init_turn_limit_->widget_set_enabled(time_limit, false);
747  turn_bonus_ ->widget_set_enabled(time_limit, false);
748  reservoir_ ->widget_set_enabled(time_limit, false);
749  action_bonus_ ->widget_set_enabled(time_limit, false);
750 
751  find_widget<button>(get_window(), "reset_timer_defaults", false).set_active(time_limit);
752 
753  if(use_map_settings) {
754  fog_ ->set_widget_value(config_engine_->fog_game_default());
755  shroud_ ->set_widget_value(config_engine_->shroud_game_default());
756  start_time_->set_widget_value(config_engine_->random_start_time_default());
757 
758  turns_ ->set_widget_value(config_engine_->num_turns_default());
759  gold_ ->set_widget_value(config_engine_->village_gold_default());
760  support_ ->set_widget_value(config_engine_->village_support_default());
761  experience_->set_widget_value(config_engine_->xp_modifier_default());
762  }
763 }
764 
766 {
768 
769  if(!load.load_multiplayer_game()) {
770  return;
771  }
772 
773  if(load.data().cancel_orders) {
775  }
776 
777  set_retval(LOAD_GAME);
778 }
779 
780 std::vector<std::string> mp_create_game::get_active_mods()
781 {
782  int i = 0;
783  std::set<std::string> res;
785  if(find_widget<toggle_button>(mod_list_->get_row_grid(i), "mod_active_state", false).get_value_bool()) {
786  res.insert(mod->id);
787  }
788  ++i;
789  }
790  return std::vector<std::string>(res.begin(), res.end());
791 }
792 
793 void mp_create_game::set_active_mods(const std::vector<std::string>& val)
794 {
795  std::set<std::string> val2(val.begin(), val.end());
796  int i = 0;
797  std::set<std::string> res;
799  find_widget<toggle_button>(mod_list_->get_row_grid(i), "mod_active_state", false).set_value_bool(val2.find(mod->id) != val2.end());
800  ++i;
801  }
802 }
803 
805 {
806  // This allows the defaults to be returned by the pref getters below
807  preferences::erase("mp_countdown_init_time");
808  preferences::erase("mp_countdown_reservoir_time");
809  preferences::erase("mp_countdown_turn_bonus");
810  preferences::erase("mp_countdown_action_bonus");
811 
816 }
817 
819 {
821  gui2::show_transient_error_message(_("The selected game has no sides!"));
822  return false;
823  }
824 
826  std::stringstream msg;
827  // TRANSLATORS: This sentence will be followed by some details of the error, most likely the "Map could not be loaded" message from create_engine.cpp
828  msg << _("The selected game cannot be created.");
829  msg << "\n\n";
832  return false;
833  }
834 
835  if(!create_engine_.is_campaign()) {
836  return true;
837  }
838 
839  return create_engine_.select_campaign_difficulty() != "CANCEL";
840 }
841 
843 {
844  plugins_context_.reset();
845 
846  // Show all tabs so that find_widget works correctly
847  find_widget<stacked_widget>(&window, "pager", false).select_layer(-1);
848 
849  if(get_retval() == LOAD_GAME) {
851 
852  // We don't need the LOAD_GAME retval past this point. For convenience, reset it to OK so we can use the execute wrapper, then exit.
854  return;
855  }
856 
857  if(get_retval() == retval::OK) {
862 
864 
865  if(create_engine_.current_level_type() == level_type::type::campaign ||
866  create_engine_.current_level_type() == level_type::type::sp_campaign) {
868  } else if(create_engine_.current_level_type() == level_type::type::scenario) {
870  } else {
871  // This means define= doesn't work for randomly generated scenarios
873  }
874 
876 
878 
879  std::vector<const config*> entry_points;
880  std::vector<std::string> entry_point_titles;
881 
882  const auto& tagname = create_engine_.get_state().classification().get_tagname();
883 
884  if(tagname == "scenario") {
885  const std::string first_scenario = create_engine_.current_level().data()["first_scenario"];
886  for(const config& scenario : game_config_manager::get()->game_config().child_range(tagname)) {
887  const bool is_first = scenario["id"] == first_scenario;
888  if(scenario["allow_new_game"].to_bool(false) || is_first || game_config::debug ) {
889  const std::string& title = !scenario["new_game_title"].empty()
890  ? scenario["new_game_title"]
891  : scenario["name"];
892 
893  entry_points.insert(is_first ? entry_points.begin() : entry_points.end(), &scenario);
894  entry_point_titles.insert(is_first ? entry_point_titles.begin() : entry_point_titles.end(), title);
895  }
896  }
897  }
898 
899  if(entry_points.size() > 1) {
900  gui2::dialogs::simple_item_selector dlg(_("Choose Starting Scenario"), _("Select at which point to begin this campaign."), entry_point_titles);
901 
902  dlg.set_single_button(true);
903  dlg.show();
904 
905  const config& scenario = *entry_points[dlg.selected_index()];
906 
907  create_engine_.get_state().mp_settings().hash = scenario.hash();
909  }
910 
911  config_engine_->set_use_map_settings(use_map_settings_->get_widget_value());
912 
913  if(!config_engine_->force_lock_settings()) {
914  // Max slider value (in this case, 100) means 'unlimited turns', so pass the value -1
915  const int num_turns = turns_->get_widget_value();
916  config_engine_->set_num_turns(num_turns < ::settings::turns_max ? num_turns : - 1);
917  config_engine_->set_village_gold(gold_->get_widget_value());
918  config_engine_->set_village_support(support_->get_widget_value());
919  config_engine_->set_xp_modifier(experience_->get_widget_value());
920  config_engine_->set_random_start_time(start_time_->get_widget_value());
921  config_engine_->set_fog_game(fog_->get_widget_value());
922  config_engine_->set_shroud_game(shroud_->get_widget_value());
923 
924  config_engine_->write_parameters();
925  }
926 
927  config_engine_->set_mp_countdown(time_limit_->get_widget_value());
928  config_engine_->set_mp_countdown_init_time(init_turn_limit_->get_widget_value());
929  config_engine_->set_mp_countdown_turn_bonus(turn_bonus_->get_widget_value());
930  config_engine_->set_mp_countdown_reservoir_time(reservoir_->get_widget_value());
931  config_engine_->set_mp_countdown_action_bonus(action_bonus_->get_widget_value());
932 
933  config_engine_->set_allow_observers(observers_->get_widget_value());
934  config_engine_->set_private_replay(private_replay_->get_widget_value());
935  config_engine_->set_oos_debug(strict_sync_->get_widget_value());
936  config_engine_->set_shuffle_sides(shuffle_sides_->get_widget_value());
937 
938  random_faction_mode::type type = random_faction_mode::get_enum(selected_rfm_index_).value_or(random_faction_mode::type::independent);
939  config_engine_->set_random_faction_mode(type);
940 
941  // Since we don't have a field handling this option, we need to save the value manually
943 
944  // Save custom option settings
945  config_engine_->set_options(options_manager_->get_options_config());
946 
947  // Set game name
948  const std::string name = find_widget<text_box>(&window, "game_name", false).get_value();
949  if(!name.empty() && (name != ng::configure_engine::game_name_default())) {
950  config_engine_->set_game_name(name);
951  }
952 
953  // Set game password
954  const std::string password = find_widget<text_box>(&window, "game_password", false).get_value();
955  if(!password.empty()) {
956  config_engine_->set_game_password(password);
957  }
958  }
959 }
960 
961 } // namespace dialogs
window(const builder_window::window_resolution &definition)
< Needs to be initialized in show.
Definition: window.cpp:263
const std::string & get_scenario() const
Returns the selected scenario.
Definition: depcheck.hpp:116
Dialog was closed with the CANCEL button.
Definition: retval.hpp:38
std::string map_size() const
void set_value_bool(bool value, bool fire_event=false)
void set_text_changed_callback(std::function< void(text_box_base *textbox, const std::string text)> cb)
Set the text_changed callback.
void set_selected(unsigned selected, bool fire_event=true)
void set_village_support(int value)
Definition: game.cpp:667
configure_engine
saved_game & get_state()
const int turns_max
maximum number of turns
void set_current_era_index(const std::size_t index, bool force=false)
The class for loading a savefile.
Definition: savegame.hpp:99
int village_support
Definition: game_config.cpp:56
void set_countdown_action_bonus(int value)
Definition: game.cpp:647
void set_countdown_turn_bonus(int value)
Definition: game.cpp:637
int min_players() const
std::string era()
Definition: game.cpp:682
A menu_button is a styled_widget to choose an element from a list of elements.
Definition: menu_button.hpp:61
void set_shroud(bool value)
Definition: game.cpp:541
void set_countdown_init_time(int value)
Definition: game.cpp:617
bool generator_assigned() const
int xp_modifier()
Definition: game.cpp:672
std::vector< extras_metadata_ptr > & get_extras_by_type(const MP_EXTRA extra_type)
void connect_signal_mouse_left_click(dispatcher &dispatcher, const signal &signal)
Connects a signal handler for a left mouse button click.
Definition: dispatcher.cpp:179
int get_era_index() const
Returns the selected era.
Definition: depcheck.cpp:399
string_enums::enum_base< random_faction_mode_defines > random_faction_mode
int find_extra_by_id(const MP_EXTRA extra_type, const std::string &id) const
void set_scenario(config scenario)
Definition: saved_game.cpp:567
std::vector< game_tip > load(const config &cfg)
Loads the tips from a config.
Definition: tips.cpp:36
std::pair< level_type::type, std::string > level_type_info
logger & info()
Definition: log.cpp:182
static std::shared_ptr< save_index_class > default_saves_dir()
Returns an instance for managing saves in filesystem::get_saves_dir()
Definition: save_index.cpp:210
void set_current_level_type(const level_type::type type)
bool generator_has_settings() const
bool shuffle_sides()
Definition: game.cpp:462
void set_widget_value(CT value)
Sets the value of the field.
Definition: field.hpp:344
int max_players() const
std::string_view data
Definition: picture.cpp:206
std::vector< level_type_info > level_types_
void set_current_level(const std::size_t index)
std::vector< std::size_t > get_filtered_level_indices(level_type::type type) const
virtual void set_value(unsigned value, bool fire_event=false) override
Inherited from selectable_item.
Definition: menu_button.hpp:87
bool is_modification_active(int index) const
Tells whether a certain mod is activated.
Definition: depcheck.cpp:428
grid & add_row(const widget_item &item, const int index=-1)
When an item in the list is selected by the user we need to update the state.
Definition: listbox.cpp:61
void on_mod_toggle(const int index, toggle_button *sender)
void set_random_faction_mode(const std::string &value)
Definition: game.cpp:477
std::vector< level_ptr > get_levels_by_type_unfiltered(level_type::type type) const
STL namespace.
static const std::string & type()
Static type getter that does not rely on the widget being constructed.
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:110
Implements some helper classes to ease adding fields to a dialog and hide the synchronization needed...
static std::string _(const char *str)
Definition: gettext.hpp:93
bool show(const unsigned auto_close_time=0)
Shows the window.
void set_countdown(bool value)
Definition: game.cpp:607
const mp_game_settings & get_parameters()
void prepare_for_era_and_mods()
bool is_campaign() const
Wrapper to simplify the is-type-campaign-or-sp-campaign check.
int countdown_init_time()
Definition: game.cpp:612
bool current_level_has_side_data()
Returns true if the current level has one or more [side] tags.
bool select_row(const unsigned row, const bool select=true)
Selects a row.
Definition: listbox.cpp:245
Class for a single line text area.
Definition: text_box.hpp:141
std::string select_campaign_difficulty(int set_value=-1)
select_campaign_difficulty
virtual std::string id() const
const config & data() const
std::vector< std::string > get_active_mods()
bool fog()
Definition: game.cpp:526
virtual void set_label(const t_string &label)
The listbox class.
Definition: listbox.hpp:45
Base container class.
Definition: grid.hpp:31
static game_config_manager * get()
virtual unsigned get_value() const override
Inherited from selectable_item.
Definition: menu_button.hpp:84
field_bool * use_map_settings_
All fields are also in the normal field vector, but they need to be manually controlled as well so ad...
int countdown_turn_bonus()
Definition: game.cpp:632
bool toggle_mod(int index, bool force=false)
void set_level_type(int value)
Definition: game.cpp:707
std::map< std::string, t_string > widget_item
Definition: widget.hpp:32
static void expand_map_file(config &scenario)
reads scenario["map_file"]
Definition: saved_game.cpp:461
A simple one-column listbox with OK and Cancel buttons.
void set_tooltip(const t_string &tooltip)
std::string level()
Definition: game.cpp:692
#define DBG_MP
int num_players() const
virtual std::string name() const
void set_metadata()
const std::string & id() const
Definition: field.hpp:183
void prepare_for_campaign(const std::string &difficulty="")
std::ostringstream wrapper.
Definition: formatter.hpp:39
void clear()
Removes all the rows in the listbox, clearing it.
Definition: listbox.cpp:120
virtual void pre_show(window &window) override
Actions to be taken before showing the window.
std::unique_ptr< plugins_context > plugins_context_
void set_visible(const visibility visible)
Definition: widget.cpp:456
void show_transient_message(const std::string &title, const std::string &message, const std::string &image, const bool message_use_markup, const bool title_use_markup)
Shows a transient message to the user.
int countdown_reservoir_time()
Definition: game.cpp:622
void erase(const std::string &key)
Definition: general.cpp:205
void set_random_start_time(bool value)
Definition: game.cpp:521
virtual void set_metadata()=0
static lg::log_domain log_mp_create("mp/create")
void set_values(const std::vector<::config > &values, unsigned selected=0)
Run hook only if result is OK.
Modify, read and display user preferences.
unsigned get_item_count() const
Returns the number of items in the listbox.
Definition: listbox.cpp:126
virtual void set_use_markup(bool use_markup)
int village_gold()
Definition: game.cpp:652
std::string campaign
The id of the campaign being played.
#define ERR_MP
ng::create_engine create_engine_
General settings and defaults for scenarios.
virtual void post_show(window &window) override
Actions to be taken after the window has been shown.
void set_active_mods(const std::vector< std::string > &val)
std::vector< std::string > & active_mods()
void apply_level_filter(const std::string &name)
void init_generated_level_data()
static const int LOAD_GAME
window * get_window()
Returns a pointer to the dialog&#39;s window.
void set_level(const std::string &value)
Definition: game.cpp:697
#define UPDATE_ATTRIBUTE(field, convert)
static std::string game_name_default()
virtual std::string icon() const
void set_allow_observers(bool value)
Definition: game.cpp:457
bool countdown()
Definition: game.cpp:602
bool shroud()
Definition: game.cpp:536
std::size_t i
Definition: function.cpp:968
level_type::type current_level_type() const
void on_filter_change(const std::string &id, bool do_select)
int selected_index() const
Returns the selected item index after displaying.
level & current_level() const
static constexpr std::optional< enum_type > get_enum(const std::string_view value)
Converts a string into its enum equivalent.
Definition: enum_base.hpp:57
std::unique_ptr< mp_options_helper > options_manager_
int convert_to_game_filtered_index(const unsigned int initial_index)
Game configuration data as global variables.
Definition: build_info.cpp:60
The user set the widget invisible, that means:
std::string password(const std::string &server, const std::string &login)
bool use_map_settings()
Definition: game.cpp:482
std::pair< level_type::type, int > find_level_by_id(const std::string &id) const
T get_widget_value()
Gets the value of the field.
Definition: field.hpp:379
Declarations for File-IO.
int w
const bool & debug
void set_retval(const int retval, const bool close_window=true)
Sets there return value of the window.
Definition: window.hpp:358
std::size_t index(const std::string &str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
Definition: unicode.cpp:72
Base class for all visible items.
#define VGETTEXT(msgid,...)
Handy wrappers around interpolate_variables_into_string and gettext.
virtual std::string description() const
boost::dynamic_bitset get_rows_shown() const
Returns a list of visible rows.
Definition: listbox.cpp:216
std::size_t current_era_index() const
virtual void set_active(const bool active) override
See styled_widget::set_active.
void set_turns(int value)
Definition: game.cpp:551
const grid * get_row_grid(const unsigned row) const
Returns the grid of the wanted row.
Definition: listbox.cpp:232
bool allow_observers()
Definition: game.cpp:452
void cancel_orders()
Definition: saved_game.cpp:686
void show_transient_error_message(const std::string &message, const std::string &image, const bool message_use_markup)
Shows a transient error message to the user.
int turns()
Definition: game.cpp:546
int get_retval() const
Returns the cached window exit code.
const std::vector< std::string > & modifications(bool mp)
Definition: game.cpp:712
const extras_metadata & current_era() const
const depcheck::manager & dependency_manager() const
Base class for all the errors encountered by the engine.
Definition: exceptions.hpp:28
void widget_set_enabled(const bool enable, const bool sync)
Enables a widget.
Definition: field.hpp:159
game_classification & classification()
Definition: saved_game.hpp:55
void set_modifications(const std::vector< std::string > &value, bool mp)
Definition: game.cpp:721
const std::string unicode_em_dash
Definition: constants.cpp:44
const std::vector< std::string > & get_modifications() const
Returns the enabled modifications.
Definition: depcheck.hpp:123
Abstract base class for all modal dialogs.
Standard logging facilities (interface).
Base class for all level type classes.
std::unique_ptr< ng::configure_engine > config_engine_
const std::vector< extras_metadata_ptr > & get_const_extras_by_type(const MP_EXTRA extra_type) const
int countdown_action_bonus()
Definition: game.cpp:642
virtual void set_active(const bool active) override
See styled_widget::set_active.
Definition: menu_button.cpp:75
void set_era(const std::string &value)
Definition: game.cpp:687
void set_shuffle_sides(bool value)
Definition: game.cpp:467
void set_fog(bool value)
Definition: game.cpp:531
std::map< std::string, widget_item > widget_data
Definition: widget.hpp:35
Dialog was closed with the OK button.
Definition: retval.hpp:35
bool dialog_exit_hook(window &)
Dialog exit hook to bring up the difficulty dialog when starting a campaign.
void display_games_of_type(level_type::type type, const std::string &level)
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:60
void show_description(const std::string &new_description)
void set_countdown_reservoir_time(int value)
Definition: game.cpp:627
bool random_start_time()
Definition: game.cpp:516
mp_game_settings & mp_settings()
Multiplayer parameters for this game.
Definition: saved_game.hpp:59
void set_xp_modifier(int value)
Definition: game.cpp:677
base class of top level items, the only item which needs to store the final canvases to draw on...
Definition: window.hpp:66
void set_row_shown(const unsigned row, const bool shown)
Makes a row visible or invisible.
Definition: listbox.cpp:138
std::string hash() const
Definition: config.cpp:1392
void set_village_gold(int value)
Definition: game.cpp:657
void set_use_map_settings(bool value)
Definition: game.cpp:487
bool empty() const
Definition: config.cpp:941
std::string get_tagname() const
Class for a toggle button.
void connect_signal_notify_modified(dispatcher &dispatcher, const signal_notification &signal)
Connects a signal handler for getting a notification upon modification.
Definition: dispatcher.cpp:205
std::pair< std::string, unsigned > item
Definition: help_impl.hpp:414
virtual bool allow_era_choice() const
virtual bool can_launch_game() const =0
void set_single_button(bool value)
Sets whether the Cancel button should be hidden or not.
int level_type()
Definition: game.cpp:702
static std::string get_string(enum_type key)
Converts a enum to its string equivalent.
Definition: enum_base.hpp:46