0ct0pu5/wesnoth
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #242 from Rift-Walker/merge_sp_mp

Browse source 
Merge single- and multi-player codepaths
This commit is contained in:
Andrius Silinskas 2014-07-14 19:08:33 +01:00
commit 35b9d5baa3
46 changed files with 884 additions and 512 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
data/_main.cfg
View file

@ -17,8 +17,17 @@
{core/}
[multiplayer_side]
id=Custom
name= _"Custom"
image="units/unknown-unit.png"
{MAGENTA_IS_THE_TEAM_COLOR}
[/multiplayer_side]
#ifdef MULTIPLAYER
{multiplayer/}
#else
{era_blank.cfg}
#endif
{campaigns/}

6
data/era_blank.cfg Normal file
View file

@ -0,0 +1,6 @@
#textdomain wesnoth
[era]
id=era_blank
name= _ "No era"
description=_ "An empty era to be used for single player campaigns."
[/era]

2
data/gui/default/window/mp_depcheck_confirm_change.cfg → data/gui/default/window/depcheck_confirm_change.cfg
View file

@ -5,7 +5,7 @@
###
[window]
id = "mp_depcheck_confirm_change"
id = "depcheck_confirm_change"
description = "Enable/disable modifications"
[resolution]

2
data/gui/default/window/mp_depcheck_select_new.cfg → data/gui/default/window/depcheck_select_new.cfg
View file

@ -5,7 +5,7 @@
###
[window]
id = "mp_depcheck_select_new"
id = "depcheck_select_new"
description = "Select new era or scenario"
[resolution]

7
data/multiplayer/eras.cfg
View file

@ -1,12 +1,5 @@
#textdomain wesnoth-multiplayer
[multiplayer_side]
id=Custom
name= _"Custom"
image="units/unknown-unit.png"
{MAGENTA_IS_THE_TEAM_COLOR}
[/multiplayer_side]
#define RANDOM_SIDE
[multiplayer_side]
id=Random

12
src/CMakeLists.txt
View file

@ -814,8 +814,8 @@ set(wesnoth-main_SRC
gui/dialogs/mp_connect.cpp
gui/dialogs/mp_create_game.cpp
gui/dialogs/mp_create_game_set_password.cpp
gui/dialogs/mp_depcheck_confirm_change.cpp
gui/dialogs/mp_depcheck_select_new.cpp
gui/dialogs/depcheck_confirm_change.cpp
gui/dialogs/depcheck_select_new.cpp
gui/dialogs/mp_host_game_prompt.cpp
gui/dialogs/mp_login.cpp
gui/dialogs/mp_method_selection.cpp
@ -842,16 +842,17 @@ set(wesnoth-main_SRC
mouse_events.cpp
mouse_handler_base.cpp
movetype.cpp
mp_depcheck.cpp
depcheck.cpp
mp_game_settings.cpp
mp_game_utils.cpp
mp_options.cpp
multiplayer.cpp
multiplayer_configure.cpp
configure_engine.cpp
multiplayer_connect.cpp
multiplayer_connect_engine.cpp
connect_engine.cpp
multiplayer_create.cpp
multiplayer_create_engine.cpp
create_engine.cpp
multiplayer_lobby.cpp
multiplayer_ui.cpp
multiplayer_wait.cpp
@ -886,6 +887,7 @@ set(wesnoth-main_SRC
scripting/lua_types.cpp
settings.cpp
side_filter.cpp
singleplayer.cpp
statistics.cpp
statistics_dialog.cpp
storyscreen/controller.cpp

12
src/SConscript
View file

@ -398,8 +398,8 @@ wesnoth_sources = Split("""
gui/dialogs/mp_connect.cpp
gui/dialogs/mp_create_game.cpp
gui/dialogs/mp_create_game_set_password.cpp
gui/dialogs/mp_depcheck_confirm_change.cpp
gui/dialogs/mp_depcheck_select_new.cpp
gui/dialogs/depcheck_confirm_change.cpp
gui/dialogs/depcheck_select_new.cpp
gui/dialogs/mp_host_game_prompt.cpp
gui/dialogs/mp_login.cpp
gui/dialogs/mp_method_selection.cpp
@ -465,16 +465,17 @@ wesnoth_sources = Split("""
mouse_events.cpp
mouse_handler_base.cpp
movetype.cpp
mp_depcheck.cpp
depcheck.cpp
mp_game_settings.cpp
mp_game_utils.cpp
mp_options.cpp
multiplayer.cpp
multiplayer_configure.cpp
configure_engine.cpp
multiplayer_connect.cpp
multiplayer_connect_engine.cpp
connect_engine.cpp
multiplayer_create.cpp
multiplayer_create_engine.cpp
create_engine.cpp
multiplayer_lobby.cpp
multiplayer_ui.cpp
multiplayer_wait.cpp
@ -509,6 +510,7 @@ wesnoth_sources = Split("""
scripting/lua_types.cpp
settings.cpp
side_filter.cpp
singleplayer.cpp
statistics.cpp
statistics_dialog.cpp
storyscreen/controller.cpp

146
src/configure_engine.cpp Normal file
View file

@ -0,0 +1,146 @@
#include "configure_engine.hpp"
#include "formula_string_utils.hpp"
#include "settings.hpp"
namespace ng {
configure_engine::configure_engine(saved_game& state) :
state_(state),
parameters_(state_.mp_settings()),
sides_(state_.get_starting_pos().child_range("side")),
cfg_(*sides_.first)
{
set_use_map_settings(use_map_settings_default());
}
void configure_engine::set_default_values() {
set_use_map_settings(use_map_settings_default());
set_game_name(game_name_default());
set_num_turns(num_turns_default());
set_village_gold(village_gold_default());
set_village_support(village_support_default());
set_xp_modifier(xp_modifier_default());
set_mp_countdown_init_time(mp_countdown_init_time_default());
set_mp_countdown_reservoir_time(mp_countdown_reservoir_time_default());
set_mp_countdown_action_bonus(mp_countdown_action_bonus_default());
set_mp_countdown(mp_countdown_default());
set_random_start_time(random_start_time_default());
set_fog_game(fog_game_default());
set_shroud_game(shroud_game_default());
}
bool configure_engine::force_lock_settings() const {
const config::attribute_value& fls = state_.get_starting_pos()["force_lock_settings"];
return (fls.empty() && state_.classification().campaign_type == game_classification::SCENARIO)
|| fls.to_bool();
}
std::string configure_engine::game_name() const { return parameters_.name; }
int configure_engine::num_turns() const { return parameters_.num_turns; }
int configure_engine::village_gold() const { return parameters_.village_gold; }
int configure_engine::village_support() const { return parameters_.village_support; }
int configure_engine::xp_modifier() const { return parameters_.xp_modifier; }
int configure_engine::mp_countdown_init_time() const { return parameters_.mp_countdown_init_time; }
int configure_engine::mp_countdown_reservoir_time() const { return parameters_.mp_countdown_reservoir_time; }
int configure_engine::mp_countdown_turn_bonus() const { return parameters_.mp_countdown_turn_bonus; }
int configure_engine::mp_countdown_action_bonus() const { return parameters_.mp_countdown_action_bonus; }
bool configure_engine::mp_countdown() const { return parameters_.mp_countdown; }
bool configure_engine::use_map_settings() const { return parameters_.use_map_settings; }
bool configure_engine::random_start_time() const { return parameters_.random_start_time; }
bool configure_engine::fog_game() const { return parameters_.fog_game; }
bool configure_engine::shroud_game() const { return parameters_.shroud_game; }
bool configure_engine::allow_observers() const { return parameters_.allow_observers; }
bool configure_engine::shuffle_sides() const { return parameters_.shuffle_sides; }
const config& configure_engine::options() const { return parameters_.options; }
void configure_engine::set_game_name(std::string val) { parameters_.name = val; }
void configure_engine::set_num_turns(int val) { parameters_.num_turns = val; }
void configure_engine::set_village_gold(int val) { parameters_.village_gold = val; }
void configure_engine::set_village_support(int val) { parameters_.village_support = val; }
void configure_engine::set_xp_modifier(int val) { parameters_.xp_modifier = val; }
void configure_engine::set_mp_countdown_init_time(int val) { parameters_.mp_countdown_init_time = val; }
void configure_engine::set_mp_countdown_reservoir_time(int val) { parameters_.mp_countdown_reservoir_time = val; }
void configure_engine::set_mp_countdown_turn_bonus(int val) { parameters_.mp_countdown_turn_bonus = val; }
void configure_engine::set_mp_countdown_action_bonus(int val) { parameters_.mp_countdown_action_bonus = val; }
void configure_engine::set_mp_countdown(bool val) { parameters_.mp_countdown = val; }
void configure_engine::set_use_map_settings(bool val) { parameters_.use_map_settings = val; }
void configure_engine::set_random_start_time(bool val) { parameters_.random_start_time = val; }
void configure_engine::set_fog_game(bool val) { parameters_.fog_game = val; }
void configure_engine::set_shroud_game(bool val) { parameters_.shroud_game = val; }
void configure_engine::set_allow_observers(bool val) { parameters_.shroud_game = val; }
void configure_engine::set_shuffle_sides(bool val) { parameters_.shuffle_sides = val; }
void configure_engine::set_options(const config& cfg) { parameters_.options = cfg; }
std::string configure_engine::game_name_default() const {
utils::string_map i18n_symbols;
i18n_symbols["login"] = preferences::login();
return vgettext("$login|’s game", i18n_symbols);
}
int configure_engine::num_turns_default() const {
return use_map_settings() ?
settings::get_turns(state_.get_starting_pos()["turns"]) :
preferences::turns();
}
int configure_engine::village_gold_default() const {
return use_map_settings() && sides_.first != sides_.second ?
settings::get_village_gold(cfg_["village_gold"], state_.classification().campaign_type) :
preferences::village_gold();
}
int configure_engine::village_support_default() const {
return use_map_settings() && sides_.first != sides_.second ?
settings::get_village_support(cfg_["village_support"]) :
preferences::village_support();
}
int configure_engine::xp_modifier_default() const {
return use_map_settings() ?
settings::get_xp_modifier(state_.get_starting_pos()["experience_modifier"]) :
preferences::xp_modifier();
}
int configure_engine::mp_countdown_init_time_default() const {
return preferences::countdown_init_time();
}
int configure_engine::mp_countdown_reservoir_time_default() const {
return preferences::countdown_reservoir_time();
}
int configure_engine::mp_countdown_turn_bonus_default() const {
return preferences::countdown_turn_bonus();
}
int configure_engine::mp_countdown_action_bonus_default() const {
return preferences::countdown_action_bonus();
}
bool configure_engine::mp_countdown_default() const {
return preferences::countdown();
}
bool configure_engine::use_map_settings_default() const {
return force_lock_settings() || preferences::use_map_settings();
}
bool configure_engine::random_start_time_default() const {
return use_map_settings() ?
state_.get_starting_pos()["random_start_time"].to_bool(true) :
preferences::random_start_time();
}
bool configure_engine::fog_game_default() const {
return use_map_settings() && sides_.first != sides_.second ?
cfg_["fog"].to_bool(state_.classification().campaign_type != game_classification::SCENARIO) :
preferences::fog();
}
bool configure_engine::shroud_game_default() const {
return use_map_settings() && sides_.first != sides_.second ?
cfg_["shroud"].to_bool(false) :
preferences::shroud();
}
bool configure_engine::allow_observers_default() const {
return preferences::allow_observers();
}
bool configure_engine::shuffle_sides_default() const {
return preferences::shuffle_sides();
}
const config& configure_engine::options_default() const {
return preferences::options();
}
const mp_game_settings& configure_engine::get_parameters() const {
return parameters_;
}
} //end namespace ng

117
src/configure_engine.hpp Normal file
View file

@ -0,0 +1,117 @@
/*
Copyright (C) 2014 by Nathan Walker <nathan.b.walker@vanderbilt.edu>
Part of the Battle for Wesnoth Project http://www.wesnoth.org/
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY.
See the COPYING file for more details.
*/
#ifndef MULTIPLAYER_CONFIGURE_ENGINE_INCLUDED
#define MULTIPLAYER_CONFIGURE_ENGINE_INCLUDED
#include "gettext.hpp"
#include "game_preferences.hpp"
#include "saved_game.hpp"
namespace ng {
/**
* configure_engine
*
* this class wraps the parameters relevent to mp_configure,
* as well as providing defaults for these parameters.
*/
class configure_engine
{
public:
configure_engine(saved_game& state);
// Set all parameters to their default values
void set_default_values();
// check force_lock_settings in config
bool force_lock_settings() const;
// getter methods
std::string game_name() const;
int num_turns() const;
int village_gold() const;
int village_support() const;
int xp_modifier() const;
int mp_countdown_init_time() const;
int mp_countdown_reservoir_time() const;
int mp_countdown_turn_bonus() const;
int mp_countdown_action_bonus() const;
bool mp_countdown() const;
bool use_map_settings() const;
bool random_start_time() const;
bool fog_game() const;
bool shroud_game() const;
bool allow_observers() const;
bool shuffle_sides() const;
const config& options() const;
// setter methods
void set_game_name(std::string name);
void set_num_turns(int val);
void set_village_gold(int val);
void set_village_support(int val);
void set_xp_modifier(int val);
void set_mp_countdown_init_time(int val);
void set_mp_countdown_reservoir_time(int val);
void set_mp_countdown_turn_bonus(int val);
void set_mp_countdown_action_bonus(int val);
void set_mp_countdown(bool val);
void set_use_map_settings(bool val);
void set_random_start_time(bool val);
void set_fog_game(bool val);
void set_shroud_game(bool val);
void set_allow_observers(bool val);
void set_shuffle_sides(bool val);
void set_options(const config& cfg);
// parameter defaults
std::string game_name_default() const;
int num_turns_default() const;
int village_gold_default() const;
int village_support_default() const;
int xp_modifier_default() const;
int mp_countdown_init_time_default() const;
int mp_countdown_reservoir_time_default() const;
int mp_countdown_turn_bonus_default() const;
int mp_countdown_action_bonus_default() const;
bool mp_countdown_default() const;
bool use_map_settings_default() const;
bool random_start_time_default() const;
bool fog_game_default() const;
bool shroud_game_default() const;
bool allow_observers_default() const;
bool shuffle_sides_default() const;
const config& options_default() const;
// parameters_ accessor
const mp_game_settings& get_parameters() const;
private:
saved_game& state_;
mp_game_settings& parameters_;
config::const_child_itors sides_;
// village gold, village support, fog, and shroud are per player, always show values of player 1.
/**
* @todo This might not be 100% correct, but at the moment
* it is not possible to show the fog and shroud per player.
* This might change in the future.
* NOTE when 'load game' is selected there are no sides.
*/
const config &cfg_;
};
} // end namespace ng
#endif

27
src/multiplayer_connect_engine.cpp → src/connect_engine.cpp
View file

@ -11,7 +11,7 @@
See the COPYING file for more details.
*/
#include "multiplayer_connect_engine.hpp"
#include "connect_engine.hpp"
#include "ai/configuration.hpp"
#include "formula_string_utils.hpp"
@ -68,7 +68,7 @@ const std::string attributes_to_trim[] = {
}
namespace mp {
namespace ng {
connect_engine::connect_engine(saved_game& state,
const bool local_players_only, const bool first_scenario) :
@ -87,7 +87,7 @@ connect_engine::connect_engine(saved_game& state,
connected_users_()
{
// Initial level config from the mp_game_settings.
level_ = initial_level_config(state_);
level_ = mp::initial_level_config(state_);
if (level_.empty()) {
return;
}
@ -451,7 +451,7 @@ void connect_engine::start_game(LOAD_USERS load_users)
save_reserved_sides_information();
// Build the gamestate object after updating the level.
level_to_gamestate(level_, state_);
mp::level_to_gamestate(level_, state_);
network::send_data(config("start_game"), 0);
}
@ -570,7 +570,7 @@ void connect_engine::start_game_commandline(
save_reserved_sides_information();
// Build the gamestate object after updating the level
level_to_gamestate(level_, state_);
mp::level_to_gamestate(level_, state_);
network::send_data(config("start_game"), 0);
}
@ -856,6 +856,7 @@ side_engine::side_engine(const config& cfg, connect_engine& parent_engine,
// Tweak the controllers.
if (cfg_["controller"] == "human_ai" ||
cfg_["controller"] == "network_ai" ||
(parent_.state_.classification().campaign_type == game_classification::SCENARIO && cfg_["controller"].blank()) ||
(cfg_["controller"] == "network" && !allow_player_ && parent_.params_.saved_game)) { //this is a workaround for bug #21797
cfg_["controller"] = "ai";
@ -1089,9 +1090,9 @@ bool side_engine::ready_for_start() const
return true;
}
if ((controller_ == mp::CNTR_COMPUTER) ||
(controller_ == mp::CNTR_EMPTY) ||
(controller_ == mp::CNTR_LOCAL)) {
if ((controller_ == CNTR_COMPUTER) ||
(controller_ == CNTR_EMPTY) ||
(controller_ == CNTR_LOCAL)) {
return true;
}
@ -1135,7 +1136,7 @@ bool side_engine::swap_sides_on_drop_target(const unsigned drop_target) {
side_engine& target = *parent_.side_engines_[drop_target];
const std::string target_id = target.player_id_;
const mp::controller target_controller = target.controller_;
const ng::controller target_controller = target.controller_;
const std::string target_ai = target.ai_algorithm_;
if ((controller_lock_ || target.controller_lock_) &&
@ -1260,7 +1261,7 @@ void side_engine::update_current_controller_index()
bool side_engine::controller_changed(const int selection)
{
const mp::controller selected_cntr = controller_options_[selection].first;
const ng::controller selected_cntr = controller_options_[selection].first;
if (selected_cntr == CNTR_LAST) {
return false;
}
@ -1279,7 +1280,7 @@ bool side_engine::controller_changed(const int selection)
return true;
}
void side_engine::set_controller(mp::controller controller)
void side_engine::set_controller(ng::controller controller)
{
controller_ = controller;
@ -1305,7 +1306,7 @@ void side_engine::set_controller_commandline(const std::string& controller_name)
player_id_.clear();
}
void side_engine::add_controller_option(mp::controller controller,
void side_engine::add_controller_option(ng::controller controller,
const std::string& name, const std::string& controller_value)
{
if (controller_lock_ && !cfg_["controller"].empty() &&
@ -1317,4 +1318,4 @@ void side_engine::add_controller_option(mp::controller controller,
controller_options_.push_back(std::make_pair(controller, name));
}
} // end namespace mp
} // end namespace ng

16
src/multiplayer_connect_engine.hpp → src/connect_engine.hpp
View file

@ -22,7 +22,7 @@
#include "saved_game.hpp"
#include <boost/scoped_ptr.hpp>
namespace mp {
namespace ng {
enum controller {
CNTR_NETWORK = 0,
@ -38,7 +38,7 @@ class side_engine;
typedef boost::scoped_ptr<connect_engine> connect_engine_ptr;
typedef boost::shared_ptr<side_engine> side_engine_ptr;
typedef std::pair<mp::controller, std::string> controller_option;
typedef std::pair<ng::controller, std::string> controller_option;
class connect_engine
{
@ -120,7 +120,7 @@ private:
const mp_game_settings& params_;
const mp::controller default_controller_;
const ng::controller default_controller_;
const bool local_players_only_;
const bool first_scenario_;
@ -165,7 +165,7 @@ public:
void update_controller_options();
void update_current_controller_index();
bool controller_changed(const int selection);
void set_controller(mp::controller controller);
void set_controller(ng::controller controller);
// Game set up from command line helpers.
void set_faction_commandline(const std::string& faction_name);
@ -178,7 +178,7 @@ public:
const std::vector<controller_option>& controller_options()
{ return controller_options_; }
const config& cfg() const { return cfg_; }
mp::controller controller() const { return controller_; }
ng::controller controller() const { return controller_; }
unsigned current_controller_index() const
{ return current_controller_index_; }
int index() const { return index_; }
@ -214,13 +214,13 @@ private:
side_engine(const side_engine& engine);
void operator=(const side_engine&);
void add_controller_option(mp::controller controller,
void add_controller_option(ng::controller controller,
const std::string& name, const std::string& controller_value);
config cfg_;
connect_engine& parent_;
mp::controller controller_;
ng::controller controller_;
unsigned current_controller_index_;
std::vector<controller_option> controller_options_;
@ -242,6 +242,6 @@ private:
flg_manager flg_;
};
} // end namespace mp
} // end namespace ng
#endif

106
src/multiplayer_create_engine.cpp → src/create_engine.cpp
View file

@ -11,11 +11,13 @@
See the COPYING file for more details.
*/
#include "multiplayer_create_engine.hpp"
#include "create_engine.hpp"
#include "game_config_manager.hpp"
#include "game_launcher.hpp"
#include "game_display.hpp"
#include "game_preferences.hpp"
#include "gui/dialogs/campaign_difficulty.hpp"
#include "filesystem.hpp"
#include "formula_string_utils.hpp"
#include "log.hpp"
@ -65,7 +67,12 @@ bool contains_ignore_case(const std::string& str1, const std::string& str2)
}
}
namespace mp {
namespace ng {
static bool less_campaigns_rank(const create_engine::level_ptr& a, const create_engine::level_ptr& b) {
return a->data()["rank"].to_int(1000) < b->data()["rank"].to_int(1000);
}
level::level(const config& data) :
data_(data)
@ -102,6 +109,11 @@ const config& level::data() const
return data_;
}
config& level::data()
{
return data_;
}
scenario::scenario(const config& data) :
level(data),
map_(),
@ -306,6 +318,11 @@ void campaign::set_metadata()
}
}
void campaign::mark_if_completed()
{
data_["completed"] = preferences::is_campaign_completed(data_["id"]);
}
std::string campaign::id() const
{
return id_;
@ -344,16 +361,20 @@ create_engine::create_engine(game_display& disp, saved_game& state) :
eras_(),
mods_(),
state_(state),
disp_(disp),
dependency_manager_(resources::config_manager->game_config(), disp.video()),
generator_(NULL)
{
DBG_MP << "restoring game config\n";
// Restore game config for multiplayer.
game_classification::CAMPAIGN_TYPE type = state_.classification().campaign_type;
state_ = saved_game();
state_.classification().campaign_type = game_classification::MULTIPLAYER;
resources::config_manager->
load_game_config_for_game(state_.classification());
state_.classification().campaign_type = type;
if(type == game_classification::MULTIPLAYER)
resources::config_manager->
load_game_config_for_game(state_.classification());
//TODO the editor dir is already configurable, is the preferences value
get_files_in_dir(get_user_data_dir() + "/editor/maps", &user_map_names_,
@ -469,6 +490,74 @@ void create_engine::prepare_for_campaign(const std::string& difficulty)
"id", current_level().data()["first_scenario"]));
}
/**
* select_campaign_difficulty
*
* Launches difficulty selection gui and returns selected difficulty name.
*
* The gui can be bypassed by supplying a number
* from 1 to the number of difficulties available,
* corresponding to a choice of difficulty.
* This is useful for specifying difficulty via command line.
*
* @param set_value Preselected difficulty number. The default -1 launches the gui.
* @return Selected difficulty. Returns "FAIL" if set_value is invalid,
* and "CANCEL" if the gui is cancelled.
*/
std::string create_engine::select_campaign_difficulty(int set_value)
{
const std::string difficulty_descriptions =
current_level().data()["difficulty_descriptions"];
std::vector<std::string> difficulty_options =
utils::split(difficulty_descriptions, ';');
const std::vector<std::string> difficulties =
utils::split(current_level().data()["difficulties"]);
if(difficulties.empty()) return "";
int difficulty = 0;
if (set_value != -1)
{
// user-specified campaign to jump to. con
if (set_value
> static_cast<int>(difficulties.size()))
{
std::cerr << "incorrect difficulty number: [" <<
set_value << "]. maximum is [" <<
difficulties.size() << "].\n";
return "FAIL";
}
else if (set_value < 1)
{
std::cerr << "incorrect difficulty number: [" <<
set_value << "]. minimum is [1].\n";
return "FAIL";
}
else
{
difficulty = set_value - 1;
}
}
else
{
if(difficulty_options.size() != difficulties.size())
{
difficulty_options = difficulties;
}
// show gui
gui2::tcampaign_difficulty dlg(difficulty_options);
dlg.show(disp_.video());
if(dlg.selected_index() == -1)
{
return "CANCEL";
}
difficulty = dlg.selected_index();
}
return difficulties[difficulty];
}
void create_engine::prepare_for_saved_game()
{
DBG_MP << "preparing mp_game_settings for saved game\n";
@ -909,12 +998,15 @@ void create_engine::init_all_levels()
campaign_ptr new_campaign(new campaign(data));
campaigns_.push_back(new_campaign);
campaigns_.back()->set_metadata();
} else {
}
if (type == "sp" || type == "hybrid" || type.empty()) {
campaign_ptr new_sp_campaign(new campaign(data));
sp_campaigns_.push_back(new_sp_campaign);
sp_campaigns_.back()->set_metadata();
sp_campaigns_.back()->mark_if_completed();
}
}
std::stable_sort(sp_campaigns_.begin(),sp_campaigns_.end(),less_campaigns_rank);
}
void create_engine::init_extras(const MP_EXTRA extra_type)
@ -1090,4 +1182,4 @@ saved_game& create_engine::get_state()
return state_;
}
} // end namespace mp
} // end namespace ng

16
src/multiplayer_create_engine.hpp → src/create_engine.hpp
View file

@ -17,7 +17,7 @@
#include "config.hpp"
#include "map.hpp"
#include "generators/mapgen.hpp"
#include "mp_depcheck.hpp"
#include "depcheck.hpp"
#include "mp_game_settings.hpp"
#include "game_display.hpp"
@ -27,8 +27,7 @@
class saved_game;
namespace mp {
namespace ng {
class level
{
public:
@ -50,6 +49,7 @@ public:
void set_data(const config& data);
const config& data() const;
config& data();
protected:
config data_;
@ -136,6 +136,8 @@ public:
void set_metadata();
void mark_if_completed();
std::string id() const;
bool allow_era_choice() const;
@ -184,6 +186,8 @@ public:
void prepare_for_scenario();
void prepare_for_campaign(const std::string& difficulty);
void prepare_for_saved_game();
std::string select_campaign_difficulty(int set_value = -1);
void apply_level_filter(const std::string& name);
void apply_level_filter(int players);
@ -226,6 +230,7 @@ public:
const mp_game_settings& get_parameters();
saved_game& get_state();
private:
create_engine(const create_engine&);
void operator=(const create_engine&);
@ -272,11 +277,12 @@ private:
saved_game& state_;
game_display& disp_;
depcheck::manager dependency_manager_;
util::scoped_ptr<map_generator> generator_;
};
} // end namespace mp
} // end namespace ng
#endif

18
src/mp_depcheck.cpp → src/depcheck.cpp
View file

@ -12,7 +12,7 @@
See the COPYING file for more details.
*/
#include "mp_depcheck.hpp"
#include "depcheck.hpp"
#include <algorithm>
@ -20,8 +20,8 @@
#include "gettext.hpp"
#include "log.hpp"
#include "gui/dialogs/mp_depcheck_confirm_change.hpp"
#include "gui/dialogs/mp_depcheck_select_new.hpp"
#include "gui/dialogs/depcheck_confirm_change.hpp"
#include "gui/dialogs/depcheck_select_new.hpp"
#include "gui/dialogs/message.hpp"
static lg::log_domain log_mp_create_depcheck("mp/create/depcheck");
@ -52,7 +52,7 @@ void copy_keys(config& out,
}
} //anonymous namespace
namespace mp
namespace ng
{
namespace depcheck
@ -429,7 +429,7 @@ bool manager::enable_mods_dialog(const std::vector<std::string>& mods,
items.push_back(depinfo_.find_child("modification", "id", mod)["name"]);
}
gui2::tmp_depcheck_confirm_change dialog(true, items, requester);
gui2::tdepcheck_confirm_change dialog(true, items, requester);
return dialog.show(video_);
}
@ -441,7 +441,7 @@ bool manager::disable_mods_dialog(const std::vector<std::string>& mods,
items.push_back(depinfo_.find_child("modification", "id", mod)["name"]);
}
gui2::tmp_depcheck_confirm_change dialog(false, items, requester);
gui2::tdepcheck_confirm_change dialog(false, items, requester);
return dialog.show(video_);
}
@ -452,7 +452,7 @@ std::string manager::change_era_dialog(const std::vector<std::string>& eras)
items.push_back(depinfo_.find_child("era", "id", era)["name"]);
}
gui2::tmp_depcheck_select_new dialog(ERA, items);
gui2::tdepcheck_select_new dialog(ERA, items);
if (dialog.show(video_)) {
return eras[dialog.result()];
@ -469,7 +469,7 @@ std::string
items.push_back(depinfo_.find_child("scenario", "id", scenario)["name"]);
}
gui2::tmp_depcheck_select_new dialog(SCENARIO, items);
gui2::tdepcheck_select_new dialog(SCENARIO, items);
if (dialog.show(video_)) {
return scenarios[dialog.result()];
}
@ -744,4 +744,4 @@ bool manager::change_modifications
} //namespace depcheck
} //namespace mp
} //namespace ng

4
src/mp_depcheck.hpp → src/depcheck.hpp
View file

@ -22,7 +22,7 @@
class CVideo;
namespace mp
namespace ng
{
namespace depcheck
@ -364,6 +364,6 @@ private:
} //namespace depcheck
} //namespace mp
} //namespace ng
#endif

17
src/flg_manager.cpp
View file

@ -21,7 +21,7 @@
#include <boost/foreach.hpp>
namespace mp {
namespace ng {
#ifdef LOW_MEM
std::string get_RC_suffix(const std::string&, const int)
@ -308,6 +308,7 @@ void flg_manager::resolve_random() {
void flg_manager::update_available_factions()
{
const config* custom_faction = NULL;
BOOST_FOREACH(const config* faction, era_factions_) {
if ((*faction)["id"] == "Custom" && side_["faction"] != "Custom" &&
has_no_recruits_) {
@ -315,6 +316,7 @@ void flg_manager::update_available_factions()
// "Custom" faction should not be available if both
// "default_recruit" and "previous_recruits" lists are empty.
// However, it should be available if it was explicitly stated so.
custom_faction = faction;
continue;
}
@ -325,6 +327,9 @@ void flg_manager::update_available_factions()
available_factions_.push_back(faction);
}
}
if (available_factions_.empty() && custom_faction) {
available_factions_.push_back(custom_faction);
}
assert(!available_factions_.empty());
@ -336,15 +341,16 @@ void flg_manager::update_available_leaders()
available_leaders_.clear();
if (!side_["no_leader"].to_bool() || !leader_lock_) {
int random_pos = 0;
// Add a default leader if there is one.
if (!default_leader_type_.empty()) {
available_leaders_.push_back(default_leader_type_);
random_pos = 1;
}
if (!saved_game_) {
if ((*current_faction_)["id"] != "Random") {
available_leaders_.push_back("random");
if ((*current_faction_)["id"] == "Custom") {
// Allow user to choose a leader from any faction.
BOOST_FOREACH(const config* f, available_factions_) {
@ -369,6 +375,9 @@ void flg_manager::update_available_leaders()
}
available_leaders_.erase(modifier, available_leaders_.end());
if (!available_leaders_.empty())
available_leaders_.insert(available_leaders_.begin() + random_pos, "random");
}
}
}
@ -575,4 +584,4 @@ int flg_manager::gender_index(const std::string& gender) const
return std::distance(choosable_genders_.begin(), it);
}
} // end namespace mp
} // end namespace ng

4
src/flg_manager.hpp
View file

@ -21,7 +21,7 @@
class config;
namespace mp {
namespace ng {
const std::string random_enemy_picture("units/random-dice.png");
@ -133,6 +133,6 @@ private:
const config* default_leader_cfg_;
};
} // end namespace mp
} // end namespace ng
#endif

3
src/game_config_manager.cpp
View file

@ -144,7 +144,8 @@ void game_config_manager::load_game_config(FORCE_RELOAD_CONFIG force_reload,
// become [multiplayer] tags and campaign's id should be added to them
// to allow to recognize which scenarios belongs to a loaded campaign.
if (classification != NULL) {
if (classification->campaign_type == game_classification::MULTIPLAYER &&
if ((classification->campaign_type == game_classification::MULTIPLAYER ||
classification->campaign_type == game_classification::SCENARIO) &&
!classification->campaign_define.empty()) {
const config& campaign = game_config().find_child("campaign",

148
src/game_launcher.cpp
View file

@ -27,8 +27,6 @@
#include "game_config_manager.hpp" // for game_config_manager
#include "game_end_exceptions.hpp" // for LEVEL_RESULT, etc
#include "gettext.hpp" // for _
#include "gui/dialogs/campaign_difficulty.hpp"
#include "gui/dialogs/campaign_selection.hpp" // for tcampaign_selection
#include "gui/dialogs/language_selection.hpp" // for tlanguage_selection
#include "gui/dialogs/message.hpp" //for show error message
#include "gui/dialogs/mp_host_game_prompt.hpp" //for host game prompt
@ -43,6 +41,7 @@
#include "log.hpp" // for LOG_STREAM, logger, general, etc
#include "map_exception.hpp"
#include "multiplayer.hpp" // for start_client, etc
#include "create_engine.hpp"
#include "network.hpp"
#include "playcampaign.hpp" // for play_game, etc
#include "preferences.hpp" // for disable_preferences_save, etc
@ -53,6 +52,7 @@
#include "sdl/utils.hpp" // for surface
#include "serialization/compression.hpp" // for format::NONE
#include "serialization/string_utils.hpp" // for split
#include "singleplayer.hpp" // for sp_create_mode
#include "statistics.hpp"
#include "tstring.hpp" // for operator==, operator!=
#include "util.hpp" // for lexical_cast_default
@ -96,10 +96,6 @@ static lg::log_domain log_network("network");
static lg::log_domain log_enginerefac("enginerefac");
#define LOG_RG LOG_STREAM(info, log_enginerefac)
static bool less_campaigns_rank(const config &a, const config &b) {
return a["rank"].to_int(1000) < b["rank"].to_int(1000);
}
game_launcher::game_launcher(const commandline_options& cmdline_opts, const char *appname) :
cmdline_opts_(cmdline_opts),
disp_(NULL),
@ -694,142 +690,8 @@ bool game_launcher::new_campaign()
state_ = saved_game();
state_.classification().campaign_type = game_classification::SCENARIO;
std::vector<config> campaigns;
BOOST_FOREACH(const config& campaign,
resources::config_manager->game_config().child_range("campaign")) {
if (campaign["type"] != "mp") {
campaigns.push_back(campaign);
}
}
mark_completed_campaigns(campaigns);
std::stable_sort(campaigns.begin(),campaigns.end(),less_campaigns_rank);
if(campaigns.begin() == campaigns.end()) {
gui2::show_error_message(disp().video(),
_("No campaigns are available.\n"));
return false;
}
int campaign_num = -1;
bool use_deterministic_mode = false;
// No campaign selected from command line
if (jump_to_campaign_.campaign_id_.empty() == true)
{
gui2::tcampaign_selection dlg(campaigns);
try {
dlg.show(disp().video());
} catch(twml_exception& e) {
e.show(disp());
return false;
}
if(dlg.get_retval() != gui2::twindow::OK) {
return false;
}
campaign_num = dlg.get_choice();
use_deterministic_mode = dlg.get_deterministic();
}
else
{
// don't reset the campaign_id_ so we can know
// if we should quit the game or return to the main menu
// checking for valid campaign name
for(size_t i = 0; i < campaigns.size(); ++i)
{
if (campaigns[i]["id"] == jump_to_campaign_.campaign_id_)
{
campaign_num = i;
break;
}
}
// didn't found any campaign with that id
if (campaign_num == -1)
{
std::cerr<<"No such campaign id to jump to: ["<<jump_to_campaign_.campaign_id_<<"]\n";
return false;
}
}
const config &campaign = campaigns[campaign_num];
state_.classification().campaign = campaign["id"].str();
state_.classification().abbrev = campaign["abbrev"].str();
std::string random_mode = use_deterministic_mode ? "deterministic" : "";
state_.carryover_sides_start["random_mode"] = random_mode;
state_.classification().random_mode = random_mode;
// we didn't specify in the command line the scenario to be started
if (jump_to_campaign_.scenario_id_.empty())
state_.carryover_sides_start["next_scenario"] = campaign["first_scenario"].str();
else
state_.carryover_sides_start["next_scenario"] = jump_to_campaign_.scenario_id_;
state_.classification().end_text = campaign["end_text"].str();
state_.classification().end_text_duration = campaign["end_text_duration"];
const std::string difficulty_descriptions = campaign["difficulty_descriptions"];
std::vector<std::string> difficulty_options = utils::split(difficulty_descriptions, ';');
const std::vector<std::string> difficulties = utils::split(campaign["difficulties"]);
if(difficulties.empty() == false) {
int difficulty = 0;
if (jump_to_campaign_.difficulty_ == -1){
if(difficulty_options.size() != difficulties.size()) {
difficulty_options.resize(difficulties.size());
std::copy(difficulties.begin(),difficulties.end(),difficulty_options.begin());
}
gui2::tcampaign_difficulty dlg(difficulty_options);
dlg.show(disp().video());
if(dlg.selected_index() == -1) {
if (jump_to_campaign_.campaign_id_.empty() == false)
{
jump_to_campaign_.campaign_id_ = "";
}
// canceled difficulty dialog, relaunch the campaign selection dialog
return new_campaign();
}
difficulty = dlg.selected_index();
}
else
{
if (jump_to_campaign_.difficulty_
> static_cast<int>(difficulties.size()))
{
std::cerr << "incorrect difficulty number: [" <<
jump_to_campaign_.difficulty_ << "]. maximum is [" <<
difficulties.size() << "].\n";
return false;
}
else if (jump_to_campaign_.difficulty_ < 1)
{
std::cerr << "incorrect difficulty number: [" <<
jump_to_campaign_.difficulty_ << "]. minimum is [1].\n";
return false;
}
else
{
difficulty = jump_to_campaign_.difficulty_ - 1;
}
}
state_.classification().difficulty = difficulties[difficulty];
}
state_.classification().campaign_define = campaign["define"].str();
state_.classification().campaign_xtra_defines = utils::split(campaign["extra_defines"]);
return true;
return sp::enter_create_mode(disp(), resources::config_manager->game_config(),
state_, jump_to_campaign_, true);
}
std::string game_launcher::jump_to_campaign_id() const
@ -842,7 +704,7 @@ bool game_launcher::goto_campaign()
if(jump_to_campaign_.jump_){
if(new_campaign()) {
jump_to_campaign_.jump_ = false;
launch_game(game_launcher::RELOAD_DATA);
launch_game(NO_RELOAD_DATA);
}else{
jump_to_campaign_.jump_ = false;
return false;

6
src/gui/dialogs/campaign_selection.cpp
View file

@ -140,8 +140,9 @@ void tcampaign_selection::pre_show(CVideo& /*video*/, twindow& window)
= find_widget<tmulti_page>(&window, "campaign_details", false);
unsigned id = 0;
FOREACH(const AUTO & campaign, campaigns_)
FOREACH(const AUTO & level, campaigns_)
{
const config& campaign = level->data();
/*** Add tree item ***/
tree_group_field["label"] = campaign["icon"];
@ -207,8 +208,9 @@ void tcampaign_selection::pre_show(CVideo& /*video*/, twindow& window)
tmulti_page& multi_page
= find_widget<tmulti_page>(&window, "campaign_details", false);
FOREACH(const AUTO & campaign, campaigns_)
FOREACH(const AUTO & level, campaigns_)
{
const config& campaign = level->data();
/*** Add list item ***/
string_map list_item;

5
src/gui/dialogs/campaign_selection.hpp
View file

@ -18,6 +18,7 @@
#include "gui/dialogs/dialog.hpp"
#include "config.hpp"
#include "create_engine.hpp"
namespace gui2
{
@ -25,7 +26,7 @@ namespace gui2
class tcampaign_selection : public tdialog
{
public:
explicit tcampaign_selection(const std::vector<config>& campaigns)
explicit tcampaign_selection(const std::vector<ng::create_engine::level_ptr>& campaigns)
: campaigns_(campaigns), choice_(-1), deterministic_(false)
{
@ -57,7 +58,7 @@ private:
void post_show(twindow& window);
/** Contains the config objects for all campaigns. */
const std::vector<config>& campaigns_;
const std::vector<ng::create_engine::level_ptr>& campaigns_;
/** The chosen campaign. */
int choice_;

10
src/gui/dialogs/mp_depcheck_confirm_change.cpp → src/gui/dialogs/depcheck_confirm_change.cpp
View file

@ -14,7 +14,7 @@
#define GETTEXT_DOMAIN "wesnoth-lib"
#include "gui/dialogs/mp_depcheck_confirm_change.hpp"
#include "gui/dialogs/depcheck_confirm_change.hpp"
#include "gui/widgets/settings.hpp"
#include "gui/widgets/window.hpp"
@ -26,9 +26,9 @@ namespace gui2
/*WIKI
* @page = GUIWindowDefinitionWML
* @order = 2_mp_depcheck_confirm_change
* @order = 2_depcheck_confirm_change
*
* == MP Dependency Check: Confirm Change ==
* == SP/MP Dependency Check: Confirm Change ==
*
* Asks the user to confirm a change required to proceed. Currently used
* for enabling/disabling modifications
@ -50,9 +50,9 @@ namespace gui2
* @end{table}
*/
REGISTER_DIALOG(mp_depcheck_confirm_change)
REGISTER_DIALOG(depcheck_confirm_change)
tmp_depcheck_confirm_change::tmp_depcheck_confirm_change(
tdepcheck_confirm_change::tdepcheck_confirm_change(
bool action,
const std::vector<std::string>& mods,
const std::string& requester)

4
src/gui/dialogs/mp_depcheck_confirm_change.hpp → src/gui/dialogs/depcheck_confirm_change.hpp
View file

@ -22,7 +22,7 @@
namespace gui2
{
class tmp_depcheck_confirm_change : public tdialog
class tdepcheck_confirm_change : public tdialog
{
public:
/**
@ -34,7 +34,7 @@ public:
* @param requester the name of the component which requests the change
*
*/
tmp_depcheck_confirm_change(bool action,
tdepcheck_confirm_change(bool action,
const std::vector<std::string>& mods,
const std::string& requester);

22
src/gui/dialogs/mp_depcheck_select_new.cpp → src/gui/dialogs/depcheck_select_new.cpp
View file

@ -14,7 +14,7 @@
#define GETTEXT_DOMAIN "wesnoth-lib"
#include "gui/dialogs/mp_depcheck_select_new.hpp"
#include "gui/dialogs/depcheck_select_new.hpp"
#include "gui/auxiliary/find_widget.tpp"
#include "gui/widgets/settings.hpp"
@ -27,9 +27,9 @@ namespace gui2
/*WIKI
* @page = GUIWindowDefinitionWML
* @order = 2_mp_depcheck_select_new
* @order = 2_depcheck_select_new
*
* == MP Dependency Check: Select New ==
* == SP/MP Dependency Check: Select New ==
*
* Offers a list of compatible items if a currently selected one is
* incompatible. Currently used for switching era or map.
@ -52,10 +52,10 @@ namespace gui2
*
*/
REGISTER_DIALOG(mp_depcheck_select_new)
REGISTER_DIALOG(depcheck_select_new)
tmp_depcheck_select_new::tmp_depcheck_select_new(
mp::depcheck::component_type name,
tdepcheck_select_new::tdepcheck_select_new(
ng::depcheck::component_type name,
const std::vector<std::string>& items)
: items_(items), result_(-1)
{
@ -63,17 +63,17 @@ tmp_depcheck_select_new::tmp_depcheck_select_new(
std::string message;
switch(name) {
case mp::depcheck::SCENARIO:
case ng::depcheck::SCENARIO:
message = _("The currently chosen scenario "
"is not compatible with your setup."
"\nPlease select a compatible one.");
break;
case mp::depcheck::ERA:
case ng::depcheck::ERA:
message = _("The currently chosen era "
"is not compatible with your setup."
"\nPlease select a compatible one.");
break;
case mp::depcheck::MODIFICATION:
case ng::depcheck::MODIFICATION:
// currently this can't happen, but be prepared for anything...
message = _("The currently chosen modification "
"is not compatible with your setup."
@ -83,7 +83,7 @@ tmp_depcheck_select_new::tmp_depcheck_select_new(
register_label("message", false, message);
}
void tmp_depcheck_select_new::pre_show(CVideo& /*video*/, twindow& window)
void tdepcheck_select_new::pre_show(CVideo& /*video*/, twindow& window)
{
tlistbox& listbox = find_widget<tlistbox>(&window, "itemlist", false);
@ -98,7 +98,7 @@ void tmp_depcheck_select_new::pre_show(CVideo& /*video*/, twindow& window)
listbox.select_row(0);
}
void tmp_depcheck_select_new::post_show(twindow& window)
void tdepcheck_select_new::post_show(twindow& window)
{
if(get_retval() == twindow::OK) {
tlistbox& listbox = find_widget<tlistbox>(&window, "itemlist", false);

6
src/gui/dialogs/mp_depcheck_select_new.hpp → src/gui/dialogs/depcheck_select_new.hpp
View file

@ -16,14 +16,14 @@
#define GUI_DIALOGS_MP_DEPCHECK_SELECT_NEW_HPP_INCLUDED
#include "gui/dialogs/dialog.hpp"
#include "mp_depcheck.hpp"
#include "depcheck.hpp"
#include <vector>
namespace gui2
{
class tmp_depcheck_select_new : public tdialog
class tdepcheck_select_new : public tdialog
{
public:
/**
@ -32,7 +32,7 @@ public:
* @param name the type of which we want to select a new item
* @param options the names of the components which can be choosed
*/
tmp_depcheck_select_new(mp::depcheck::component_type name,
tdepcheck_select_new(ng::depcheck::component_type name,
const std::vector<std::string>& options);
/**

3
src/mp_game_utils.cpp
View file

@ -157,8 +157,9 @@ config initial_level_config(saved_game& state)
void level_to_gamestate(const config& level, saved_game& state)
{
game_classification::CAMPAIGN_TYPE type = state.classification().campaign_type;
state = saved_game(level);
state.classification().campaign_type = game_classification::MULTIPLAYER;
state.classification().campaign_type = type;
// Any replay data is only temporary and should be removed from
// the level data in case we want to save the game later.
if (const config& replay_data = level.child("replay"))

2
src/mp_options.hpp
View file

@ -36,7 +36,7 @@ namespace options
config to_event(const config& options);
// TODO: there's an identical enum in mp_depcheck.hpp, maybe we should factor
// TODO: there's an identical enum in depcheck.hpp, maybe we should factor
// out?
enum elem_type
{

11
src/multiplayer.cpp
View file

@ -30,6 +30,7 @@
#include "generators/map_create.hpp"
#include "mp_game_utils.hpp"
#include "multiplayer_configure.hpp"
#include "configure_engine.hpp"
#include "multiplayer_connect.hpp"
#include "multiplayer_create.hpp"
#include "multiplayer_error_codes.hpp"
@ -489,7 +490,7 @@ static bool enter_connect_mode(game_display& disp, const config& game_config,
statistics::fresh_stats();
{
mp::connect_engine_ptr connect_engine(new mp::connect_engine(state, local_players_only, true));
ng::connect_engine_ptr connect_engine(new ng::connect_engine(state, local_players_only, true));
mp::connect ui(disp, state.mp_settings().name, game_config, gamechat, gamelist,
*connect_engine);
run_lobby_loop(disp, ui);
@ -501,7 +502,7 @@ static bool enter_connect_mode(game_display& disp, const config& game_config,
if (res == mp::ui::PLAY) {
ui.start_game();
}
}
} // end connect_engine_ptr scope
switch (res) {
case mp::ui::PLAY:
@ -523,7 +524,7 @@ static bool enter_connect_mode(game_display& disp, const config& game_config,
}
static bool enter_configure_mode(game_display& disp, const config& game_config,
saved_game& state,
saved_game& state,
bool local_players_only = false);
static void enter_create_mode(game_display& disp, const config& game_config,
@ -867,7 +868,7 @@ void start_local_game_commandline(game_display& disp, const config& game_config,
statistics::fresh_stats();
{
mp::connect_engine_ptr connect_engine(new mp::connect_engine(state, true, true));
ng::connect_engine_ptr connect_engine(new ng::connect_engine(state, true, true));
mp::connect ui(disp, parameters.name, game_config, gamechat, gamelist,
*connect_engine);
@ -911,7 +912,7 @@ void start_client(game_display& disp, const config& game_config,
}
}
mp::ui::result goto_mp_connect(game_display& disp, connect_engine& engine,
mp::ui::result goto_mp_connect(game_display& disp, ng::connect_engine& engine,
const config& game_config, const std::string& game_name)
{
mp::ui::result res;

4
src/multiplayer.hpp
View file

@ -16,7 +16,7 @@
#include "commandline_options.hpp"
#include "mp_game_settings.hpp"
#include "multiplayer_connect_engine.hpp"
#include "connect_engine.hpp"
#include "multiplayer_ui.hpp"
class config;
@ -60,7 +60,7 @@ void start_client(game_display& disp, const config& game_config,
* Opens mp::connect screen and sets game state according to the
* changes made.
*/
mp::ui::result goto_mp_connect(game_display& disp, connect_engine& engine,
mp::ui::result goto_mp_connect(game_display& disp, ng::connect_engine& engine,
const config& game_config, const std::string& game_name);
/**

192
src/multiplayer_configure.cpp
View file

@ -89,85 +89,90 @@ configure::configure(game_display& disp, const config &cfg, chat& c, config& gam
options_pane_right_(disp.video()),
entry_points_(),
show_entry_points_(false),
force_use_map_settings_check_(true),
force_use_map_settings_check_(false),
state_(game),
parameters_(state_.mp_settings()),
options_manager_(cfg, disp, &options_pane_right_, preferences::options())
engine_(state_),
options_manager_(cfg, disp, &options_pane_right_, engine_.options_default())
{
// Build the list of scenarios to play
DBG_MP << "constructing multiplayer configure dialog" << std::endl;
use_map_settings_.enable(!engine_.force_lock_settings());
use_map_settings_.set_check(engine_.use_map_settings());
use_map_settings_.set_help_string(_("Use scenario specific settings"));
turns_slider_.set_min(settings::turns_min);
turns_slider_.set_max(settings::turns_max);
turns_slider_.set_increment(settings::turns_step);
turns_slider_.set_value(preferences::turns());
turns_slider_.set_value(engine_.num_turns_default());
turns_slider_.set_help_string(_("The maximum number of turns the game can last"));
turns_slider_.enable(!engine_.use_map_settings());
countdown_game_.set_check(preferences::countdown());
countdown_game_.set_check(engine_.mp_countdown_default());
countdown_game_.set_help_string(_("Enables user time limit"));
countdown_init_time_slider_.set_min(30);
countdown_init_time_slider_.set_max(1500);
countdown_init_time_slider_.set_increment(30);
countdown_init_time_slider_.set_value(preferences::countdown_init_time());
countdown_init_time_slider_.set_value(engine_.mp_countdown_init_time_default());
countdown_init_time_slider_.set_help_string(_("Longest time allowed for first turn (seconds)"));
countdown_reservoir_time_slider_.set_min(30);
countdown_reservoir_time_slider_.set_max(1500);
countdown_reservoir_time_slider_.set_increment(30);
countdown_reservoir_time_slider_.set_value(preferences::countdown_reservoir_time());
countdown_reservoir_time_slider_.set_value(engine_.mp_countdown_reservoir_time_default());
countdown_reservoir_time_slider_.set_help_string(_("Longest time possible for any turn (seconds)"));
countdown_turn_bonus_slider_.set_min(10);
countdown_turn_bonus_slider_.set_max(300);
countdown_turn_bonus_slider_.set_increment(5);
countdown_turn_bonus_slider_.set_value(preferences::countdown_turn_bonus());
countdown_turn_bonus_slider_.set_value(engine_.mp_countdown_turn_bonus_default());
countdown_turn_bonus_slider_.set_help_string(_("Time for general tasks each turn (seconds)"));
countdown_action_bonus_slider_.set_min(0);
countdown_action_bonus_slider_.set_max(30);
countdown_action_bonus_slider_.set_increment(1);
countdown_action_bonus_slider_.set_value(preferences::countdown_action_bonus());
countdown_action_bonus_slider_.set_value(engine_.mp_countdown_action_bonus_default());
countdown_action_bonus_slider_.set_help_string(_("Time for each attack, recruit, and capture"));
village_gold_slider_.set_min(1);
village_gold_slider_.set_max(5);
village_gold_slider_.set_value(preferences::village_gold());
village_gold_slider_.set_value(engine_.village_gold_default());
village_gold_slider_.set_help_string(_("The amount of income each village yields per turn"));
village_gold_slider_.enable(!engine_.use_map_settings());
village_support_slider_.set_min(0);
village_support_slider_.set_max(4);
village_support_slider_.set_value(preferences::village_support());
village_support_slider_.set_value(engine_.village_support_default());
village_support_slider_.set_help_string(_("The number of unit levels each village can support"));
village_support_slider_.enable(!engine_.use_map_settings());
xp_modifier_slider_.set_min(30);
xp_modifier_slider_.set_max(200);
xp_modifier_slider_.set_value(preferences::xp_modifier());
xp_modifier_slider_.set_value(engine_.xp_modifier_default());
xp_modifier_slider_.set_increment(10);
xp_modifier_slider_.set_help_string(_("The amount of experience a unit needs to advance"));
xp_modifier_slider_.enable(!engine_.use_map_settings());
if (state_.get_starting_pos()["force_lock_settings"].to_bool()) {
use_map_settings_.enable(false);
use_map_settings_.set_check(true);
} else {
use_map_settings_.set_check(preferences::use_map_settings());
}
use_map_settings_.set_help_string(_("Use scenario specific settings"));
random_start_time_.set_check(preferences::random_start_time());
random_start_time_.set_check(engine_.random_start_time_default());
random_start_time_.set_help_string(_("Randomize time of day in begin"));
random_start_time_.enable(!engine_.use_map_settings());
fog_game_.set_check(preferences::fog());
fog_game_.set_check(engine_.fog_game_default());
fog_game_.set_help_string(_("Enemy units cannot be seen unless they are in range of your units"));
fog_game_.enable(!engine_.use_map_settings());
shroud_game_.set_check(preferences::shroud());
shroud_game_.set_check(engine_.shroud_game_default());
shroud_game_.set_help_string(_("The map is unknown until your units explore it"));
shroud_game_.enable(!engine_.use_map_settings());
observers_game_.set_check(preferences::allow_observers());
observers_game_.set_check(engine_.allow_observers_default());
observers_game_.set_help_string(_("Allow users who are not playing to watch the game"));
shuffle_sides_.set_check(preferences::shuffle_sides());
shuffle_sides_.set_check(engine_.shuffle_sides_default());
shuffle_sides_.set_help_string(_("Assign sides to players at random"));
#if 0
@ -206,9 +211,7 @@ configure::configure(game_display& disp, const config &cfg, chat& c, config& gam
options_manager_.set_modifications(parameters_.active_mods);
options_manager_.init_widgets();
utils::string_map i18n_symbols;
i18n_symbols["login"] = preferences::login();
name_entry_.set_text(vgettext("$login|’s game", i18n_symbols));
name_entry_.set_text(engine_.game_name_default());
gamelist_updated();
}
@ -225,26 +228,26 @@ configure::~configure()
// Save values for next game
DBG_MP << "storing parameter values in preferences" << std::endl;
preferences::set_allow_observers(parameters_.allow_observers);
preferences::set_shuffle_sides(parameters_.shuffle_sides);
preferences::set_use_map_settings(parameters_.use_map_settings);
preferences::set_countdown(parameters_.mp_countdown);
preferences::set_countdown_init_time(parameters_.mp_countdown_init_time);
preferences::set_countdown_turn_bonus(parameters_.mp_countdown_turn_bonus);
preferences::set_countdown_reservoir_time(parameters_.mp_countdown_reservoir_time);
preferences::set_countdown_action_bonus(parameters_.mp_countdown_action_bonus);
preferences::set_options(parameters_.options);
preferences::set_allow_observers(engine_.allow_observers());
preferences::set_shuffle_sides(engine_.shuffle_sides());
preferences::set_use_map_settings(engine_.use_map_settings());
preferences::set_countdown(engine_.mp_countdown());
preferences::set_countdown_init_time(engine_.mp_countdown_init_time());
preferences::set_countdown_turn_bonus(engine_.mp_countdown_turn_bonus());
preferences::set_countdown_reservoir_time(engine_.mp_countdown_reservoir_time());
preferences::set_countdown_action_bonus(engine_.mp_countdown_action_bonus());
preferences::set_options(engine_.options());
// When using map settings, the following variables are determined by the map,
// so don't store them as the new preferences.
if(!parameters_.use_map_settings) {
preferences::set_fog(parameters_.fog_game);
preferences::set_shroud(parameters_.shroud_game);
preferences::set_turns(parameters_.num_turns);
preferences::set_random_start_time(parameters_.random_start_time);
preferences::set_village_gold(parameters_.village_gold);
preferences::set_village_support(parameters_.village_support);
preferences::set_xp_modifier(parameters_.xp_modifier);
if(!engine_.use_map_settings()) {
preferences::set_fog(engine_.fog_game());
preferences::set_shroud(engine_.shroud_game());
preferences::set_turns(engine_.num_turns());
preferences::set_random_start_time(engine_.random_start_time());
preferences::set_village_gold(engine_.village_gold());
preferences::set_village_support(engine_.village_support());
preferences::set_xp_modifier(engine_.xp_modifier());
}
} catch (...) {}
}
@ -266,30 +269,30 @@ const mp_game_settings& configure::get_parameters()
const int num_turns_val = turns_slider_.value() <
turns_slider_.max_value() ? turns_slider_.value() : -1;
// Updates the values in the "parameters_" member to match
// Updates the values in the configure_engine to match
// the values selected by the user with the widgets:
parameters_.name = name_entry_.text();
engine_.set_game_name(name_entry_.text());
// CHECK
parameters_.mp_countdown_init_time = mp_countdown_init_time_val;
parameters_.mp_countdown_turn_bonus = mp_countdown_turn_bonus_val;
parameters_.mp_countdown_reservoir_time = mp_countdown_reservoir_time_val;
parameters_.mp_countdown_action_bonus = mp_countdown_action_bonus_val;
parameters_.mp_countdown = countdown_game_.checked();
parameters_.num_turns = num_turns_val;
parameters_.village_gold = village_gold_slider_.value();
parameters_.village_support = village_support_slider_.value();
parameters_.xp_modifier = xp_modifier_slider_.value();
parameters_.use_map_settings = use_map_settings_.checked();
parameters_.random_start_time = random_start_time_.checked();
parameters_.fog_game = fog_game_.checked();
parameters_.shroud_game = shroud_game_.checked();
parameters_.allow_observers = observers_game_.checked();
parameters_.shuffle_sides = shuffle_sides_.checked();
engine_.set_mp_countdown_init_time(mp_countdown_init_time_val);
engine_.set_mp_countdown_turn_bonus(mp_countdown_turn_bonus_val);
engine_.set_mp_countdown_reservoir_time(mp_countdown_reservoir_time_val);
engine_.set_mp_countdown_action_bonus(mp_countdown_action_bonus_val);
engine_.set_mp_countdown(countdown_game_.checked());
engine_.set_num_turns(num_turns_val);
engine_.set_village_gold(village_gold_slider_.value());
engine_.set_village_support(village_support_slider_.value());
engine_.set_xp_modifier(xp_modifier_slider_.value());
engine_.set_use_map_settings(use_map_settings_.checked());
engine_.set_random_start_time(random_start_time_.checked());
engine_.set_fog_game(fog_game_.checked());
engine_.set_shroud_game(shroud_game_.checked());
engine_.set_allow_observers(observers_game_.checked());
engine_.set_shuffle_sides(shuffle_sides_.checked());
parameters_.options = options_manager_.get_values();
engine_.set_options(options_manager_.get_values());
return parameters_;
return engine_.get_parameters();
}
void configure::process_event()
@ -403,59 +406,26 @@ void configure::process_event()
if(use_map_settings_.pressed() || force_use_map_settings_check_) {
force_use_map_settings_check_ = false;
const bool map_settings = use_map_settings_.checked();
engine_.set_use_map_settings(use_map_settings_.checked());
// If the map settings are wanted use them,
// if not properly defined fall back to the default settings
turns_slider_.set_value(map_settings ?
settings::get_turns(state_.get_starting_pos()["turns"]) :
preferences::turns());
xp_modifier_slider_.set_value(map_settings ?
settings::get_xp_modifier(state_.get_starting_pos()["experience_modifier"]) :
preferences::xp_modifier());
random_start_time_.set_check(map_settings ?
state_.get_starting_pos()["random_start_time"].to_bool(true) :
preferences::random_start_time());
// These are per player, always show values of player 1.
/**
* @todo This might not be 100% correct, but at the moment
* it is not possible to show the fog and shroud per player.
* This might change in the future.
* NOTE when 'load game' is selected there are no sides.
*/
config::const_child_itors sides = state_.get_starting_pos().child_range("side");
if (sides.first != sides.second)
{
const config &cfg = *sides.first;
village_gold_slider_.set_value(map_settings ?
settings::get_village_gold(cfg["village_gold"]) :
preferences::village_gold());
village_support_slider_.set_value(map_settings ?
settings::get_village_support(cfg["village_support"]) :
preferences::village_support());
fog_game_.set_check(map_settings ?
cfg["fog"].to_bool(true) :
preferences::fog());
shroud_game_.set_check(map_settings ?
cfg["shroud"].to_bool(false) :
preferences::shroud());
}
turns_slider_.set_value(engine_.num_turns_default());
xp_modifier_slider_.set_value(engine_.xp_modifier_default());
random_start_time_.set_check(engine_.xp_modifier_default());
village_gold_slider_.set_value(engine_.village_gold_default());
village_support_slider_.set_value(engine_.village_support_default());
fog_game_.set_check(engine_.fog_game_default());
shroud_game_.set_check(engine_.shroud_game_default());
// Set the widget states
turns_slider_.enable(!map_settings);
village_gold_slider_.enable(!map_settings);
village_support_slider_.enable(!map_settings);
xp_modifier_slider_.enable(!map_settings);
random_start_time_.enable(!map_settings);
fog_game_.enable(!map_settings);
shroud_game_.enable(!map_settings);
turns_slider_.enable(!engine_.use_map_settings());
village_gold_slider_.enable(!engine_.use_map_settings());
village_support_slider_.enable(!engine_.use_map_settings());
xp_modifier_slider_.enable(!engine_.use_map_settings());
random_start_time_.enable(!engine_.use_map_settings());
fog_game_.enable(!engine_.use_map_settings());
shroud_game_.enable(!engine_.use_map_settings());
}
options_manager_.process_event();

4
src/multiplayer_configure.hpp
View file

@ -15,7 +15,7 @@
#ifndef MULTIPLAYER_CONFIGURE_HPP_INCLUDED
#define MULTIPLAYER_CONFIGURE_HPP_INCLUDED
#include "mp_depcheck.hpp"
#include "depcheck.hpp"
#include "mp_game_settings.hpp"
#include "multiplayer_ui.hpp"
#include "widgets/slider.hpp"
@ -24,6 +24,7 @@
#include "generators/mapgen.hpp"
#include "tooltips.hpp"
#include "mp_options.hpp"
#include "configure_engine.hpp"
class saved_game;
namespace mp {
@ -96,6 +97,7 @@ private:
bool force_use_map_settings_check_;
saved_game& state_;
mp_game_settings& parameters_;
ng::configure_engine engine_;
options::manager options_manager_;
};

12
src/multiplayer_connect.cpp
View file

@ -39,17 +39,17 @@ static lg::log_domain log_mp_connect("mp/connect");
namespace mp {
std::vector<std::string> controller_options_names(
const std::vector<controller_option>& controller_options)
const std::vector<ng::controller_option>& controller_options)
{
std::vector<std::string> names;
BOOST_FOREACH(const controller_option& option, controller_options) {
BOOST_FOREACH(const ng::controller_option& option, controller_options) {
names.push_back(option.second);
}
return names;
}
connect::side::side(connect& parent, side_engine_ptr engine) :
connect::side::side(connect& parent, ng::side_engine_ptr engine) :
parent_(&parent),
engine_(engine),
gold_lock_(engine_->cfg()["gold_lock"].to_bool(
@ -343,7 +343,7 @@ void connect::side::update_controller_ui()
// Adjust the visibility of AI algorithm combo
// and original controller label.
if (!parent_->hidden()) {
if (engine_->controller() == CNTR_COMPUTER) {
if (engine_->controller() == ng::CNTR_COMPUTER) {
// Computer selected, show AI combo.
combo_ai_algorithm_.hide(false);
@ -362,7 +362,7 @@ void connect::side::update_controller_ui()
connect::connect(game_display& disp, const std::string& game_name,
const config& game_config, chat& c, config& gamelist,
connect_engine& engine) :
ng::connect_engine& engine) :
mp::ui(disp, _("Game Lobby: ") + game_name, game_config, c, gamelist),
player_colors_(),
ai_algorithms_(),
@ -409,7 +409,7 @@ connect::connect(game_display& disp, const std::string& game_name,
}
// Sides.
BOOST_FOREACH(side_engine_ptr s, engine_.side_engines()) {
BOOST_FOREACH(ng::side_engine_ptr s, engine_.side_engines()) {
sides_.push_back(side(*this, s));
}
if (sides_.empty() && !game_config::debug) {

16
src/multiplayer_connect.hpp
View file

@ -18,7 +18,7 @@
#define MULTIPLAYER_CONNECT_H_INCLUDED
#include "commandline_options.hpp"
#include "multiplayer_connect_engine.hpp"
#include "connect_engine.hpp"
#include "multiplayer_ui.hpp"
#include "widgets/combo_drag.hpp"
#include "widgets/scrollpane.hpp"
@ -32,7 +32,7 @@ namespace mp {
// Helper function to retrieve controller names.
std::vector<std::string> controller_options_names(
const std::vector<controller_option>& controller_options);
const std::vector<ng::controller_option>& controller_options);
class connect : public mp::ui
{
@ -40,7 +40,7 @@ public:
class side {
public:
side(connect& parent, side_engine_ptr engine);
side(connect& parent, ng::side_engine_ptr engine);
side(const side& a);
~side();
@ -53,8 +53,8 @@ public:
void add_widgets_to_scrollpane(gui::scrollpane& pane, int pos);
side_engine_ptr engine() { return engine_; }
const side_engine_ptr engine() const { return engine_; }
ng::side_engine_ptr engine() { return engine_; }
const ng::side_engine_ptr engine() const { return engine_; }
private:
// Update UI methods and their helper(s).
@ -63,7 +63,7 @@ public:
// The mp::connect widget owning this mp::connect::side.
connect* parent_;
side_engine_ptr engine_;
ng::side_engine_ptr engine_;
// Flags for controlling which configuration widgets should be locked.
bool gold_lock_;
@ -93,7 +93,7 @@ public:
connect(game_display& disp, const std::string& game_name,
const config& game_config, chat& c, config& gamelist,
connect_engine& engine);
ng::connect_engine& engine);
~connect();
// Updates the current game state, resolves random factions, and sends a
@ -130,7 +130,7 @@ private:
std::vector<ai::description*> ai_algorithms_;
side_list sides_;
connect_engine& engine_;
ng::connect_engine& engine_;
gui::label waiting_label_;
gui::label type_title_label_;

93
src/multiplayer_create.cpp
View file

@ -100,16 +100,16 @@ create::create(game_display& disp, const config& cfg, saved_game& state,
levels_menu_.set_numeric_keypress_selection(false);
typedef std::pair<level::TYPE, std::string> level_type_info;
typedef std::pair<ng::level::TYPE, std::string> level_type_info;
std::vector<level_type_info> all_level_types;
all_level_types.push_back(std::make_pair(level::SCENARIO, _("Scenarios")));
all_level_types.push_back(std::make_pair(level::CAMPAIGN, _("Campaigns")));
all_level_types.push_back(std::make_pair(level::USER_MAP, _("User Maps")));
all_level_types.push_back(std::make_pair(level::USER_SCENARIO, _("User Scenarios")));
all_level_types.push_back(std::make_pair(level::RANDOM_MAP, _("Random Maps")));
all_level_types.push_back(std::make_pair(ng::level::SCENARIO, _("Scenarios")));
all_level_types.push_back(std::make_pair(ng::level::CAMPAIGN, _("Campaigns")));
all_level_types.push_back(std::make_pair(ng::level::USER_MAP, _("User Maps")));
all_level_types.push_back(std::make_pair(ng::level::USER_SCENARIO, _("User Scenarios")));
all_level_types.push_back(std::make_pair(ng::level::RANDOM_MAP, _("Random Maps")));
if (game_config::debug) {
all_level_types.push_back(std::make_pair(level::SP_CAMPAIGN,
all_level_types.push_back(std::make_pair(ng::level::SP_CAMPAIGN,
"SP Campaigns"));
}
@ -134,7 +134,7 @@ create::create(game_display& disp, const config& cfg, saved_game& state,
// Set level selection according to the preferences, if possible.
size_t type_index = 0;
BOOST_FOREACH(level::TYPE type, available_level_types_) {
BOOST_FOREACH(ng::level::TYPE type, available_level_types_) {
if (preferences::level_type() == type) {
break;
}
@ -153,7 +153,7 @@ create::create(game_display& disp, const config& cfg, saved_game& state,
init_level_type_changed(level_new_selection);
const std::vector<std::string>& era_names =
engine_.extras_menu_item_names(create_engine::ERA);
engine_.extras_menu_item_names(ng::create_engine::ERA);
if(era_names.empty()) {
gui2::show_transient_message(disp.video(), "", _("No eras found."));
throw config::error(_("No eras found"));
@ -161,11 +161,11 @@ create::create(game_display& disp, const config& cfg, saved_game& state,
eras_menu_.set_items(era_names);
// Set era selection according to the preferences, if possible.
int era_new_selection = engine_.find_extra_by_id(create_engine::ERA,
int era_new_selection = engine_.find_extra_by_id(ng::create_engine::ERA,
preferences::era());
eras_menu_.move_selection((era_new_selection != -1) ? era_new_selection : 0);
std::vector<std::string> mods = engine_.extras_menu_item_names(create_engine::MOD);
std::vector<std::string> mods = engine_.extras_menu_item_names(ng::create_engine::MOD);
BOOST_FOREACH(std::string& mod, mods) {
std::stringstream newval;
newval << IMAGE_PREFIX << "buttons/checkbox.png" << COLUMN_SEPARATOR << mod;
@ -198,7 +198,7 @@ create::~create()
// Save values for next game
DBG_MP << "storing parameter values in preferences" << std::endl;
preferences::set_era(engine_.current_extra(create_engine::ERA).id);
preferences::set_era(engine_.current_extra(ng::create_engine::ERA).id);
preferences::set_level(engine_.current_level().id());
preferences::set_level_type(engine_.current_level_type());
preferences::set_modifications(engine_.active_mods());
@ -226,10 +226,10 @@ void create::process_event()
engine_.prepare_for_era_and_mods();
if (engine_.current_level_type() == level::CAMPAIGN ||
engine_.current_level_type() == level::SP_CAMPAIGN) {
if (engine_.current_level_type() == ng::level::CAMPAIGN ||
engine_.current_level_type() == ng::level::SP_CAMPAIGN) {
std::string difficulty = select_campaign_difficulty();
std::string difficulty = engine_.select_campaign_difficulty();
if (difficulty == "CANCEL") {
return;
}
@ -288,7 +288,7 @@ void create::process_event()
if (update_mod_button_label) {
mod_selection_ = mods_menu_.selection();
engine_.set_current_mod_index(mod_selection_);
set_description(engine_.current_extra(create_engine::MOD).description);
set_description(engine_.current_extra(ng::create_engine::MOD).description);
if (engine_.dependency_manager().is_modification_active(mod_selection_)) {
select_mod_.set_label(_("Deactivate"));
} else {
@ -302,7 +302,7 @@ void create::process_event()
if (era_changed) {
engine_.set_current_era_index(era_selection_);
set_description(engine_.current_extra(create_engine::ERA).description);
set_description(engine_.current_extra(ng::create_engine::ERA).description);
synchronize_selections();
}
@ -353,23 +353,23 @@ void create::process_event()
set_description(engine_.current_level().description());
switch (engine_.current_level_type()) {
case level::SCENARIO:
case level::USER_MAP:
case level::USER_SCENARIO:
case level::RANDOM_MAP: {
case ng::level::SCENARIO:
case ng::level::USER_MAP:
case ng::level::USER_SCENARIO:
case ng::level::RANDOM_MAP: {
scenario* current_scenario =
dynamic_cast<scenario*>(&engine_.current_level());
ng::scenario* current_scenario =
dynamic_cast<ng::scenario*>(&engine_.current_level());
players << current_scenario->num_players();
map_size << _("Size: ") << current_scenario->map_size();
break;
}
case level::CAMPAIGN:
case level::SP_CAMPAIGN: {
campaign* current_campaign =
dynamic_cast<campaign*>(&engine_.current_level());
case ng::level::CAMPAIGN:
case ng::level::SP_CAMPAIGN: {
ng::campaign* current_campaign =
dynamic_cast<ng::campaign*>(&engine_.current_level());
players << current_campaign->min_players();
if (current_campaign->max_players() !=
@ -446,13 +446,13 @@ void create::synchronize_selections()
process_event();
}
if (engine_.current_level_type() != level::CAMPAIGN &&
engine_.current_level_type() != level::SP_CAMPAIGN) {
if (engine_.current_level_type() != ng::level::CAMPAIGN &&
engine_.current_level_type() != ng::level::SP_CAMPAIGN) {
if (engine_.current_level().id() !=
engine_.dependency_manager().get_scenario()) {
// Match scenario and scenario type
level::TYPE level_type_at_index;
ng::level::TYPE level_type_at_index;
int index = engine_.find_level_by_id(
engine_.dependency_manager().get_scenario());
size_t type_index;
@ -468,7 +468,7 @@ void create::synchronize_selections()
levels_menu_.set_items(engine_.levels_menu_item_names());
levels_menu_.move_selection(index);
type_index = 0;
BOOST_FOREACH(level::TYPE type, available_level_types_) {
BOOST_FOREACH(ng::level::TYPE type, available_level_types_) {
if (level_type_at_index == type) {
level_type_combo_.set_selected(type_index);
break;
@ -521,35 +521,6 @@ void create::update_mod_menu_images()
}
}
std::string create::select_campaign_difficulty()
{
const std::string difficulty_descriptions =
engine_.current_level().data()["difficulty_descriptions"];
std::vector<std::string> difficulty_options =
utils::split(difficulty_descriptions, ';');
const std::vector<std::string> difficulties =
utils::split(engine_.current_level().data()["difficulties"]);
if(!difficulties.empty()) {
int difficulty = 0;
if(difficulty_options.size() != difficulties.size()) {
difficulty_options = difficulties;
}
gui2::tcampaign_difficulty dlg(difficulty_options);
dlg.show(disp().video());
if(dlg.selected_index() == -1) {
return "CANCEL";
}
difficulty = dlg.selected_index();
return difficulties[difficulty];
}
return "";
}
void create::hide_children(bool hide)
{
DBG_MP << (hide ? "hiding" : "showing" ) << " children widgets" << std::endl;
@ -710,7 +681,7 @@ void create::layout_children(const SDL_Rect& rect)
eras_menu_.set_location(xpos, ypos);
// Menu dimensions are only updated when items are set. So do this now.
int erasel_save = eras_menu_.selection();
eras_menu_.set_items(engine_.extras_menu_item_names(create_engine::ERA));
eras_menu_.set_items(engine_.extras_menu_item_names(ng::create_engine::ERA));
eras_menu_.move_selection(erasel_save);
ypos += eras_menu_height;

8
src/multiplayer_create.hpp
View file

@ -17,8 +17,8 @@
#ifndef MULTIPLAYER_CREATE_HPP_INCLUDED
#define MULTIPLAYER_CREATE_HPP_INCLUDED
#include "mp_depcheck.hpp"
#include "multiplayer_create_engine.hpp"
#include "depcheck.hpp"
#include "create_engine.hpp"
#include "multiplayer_ui.hpp"
#include "widgets/slider.hpp"
#include "widgets/combo.hpp"
@ -91,9 +91,9 @@ private:
util::scoped_ptr<surface_restorer> image_restorer_;
SDL_Rect image_rect_;
std::vector<level::TYPE> available_level_types_;
std::vector<ng::level::TYPE> available_level_types_;
create_engine engine_;
ng::create_engine engine_;
};
} // end namespace mp

8
src/multiplayer_wait.cpp
View file

@ -53,7 +53,7 @@ const int leader_pane_border = 10;
namespace mp {
wait::leader_preview_pane::leader_preview_pane(game_display& disp,
flg_manager& flg, const int color) :
ng::flg_manager& flg, const int color) :
gui::preview_pane(disp.video()),
flg_(flg),
color_(color),
@ -114,7 +114,7 @@ void wait::leader_preview_pane::draw_contents()
if (ut) {
const unit_type &utg = ut->get_gender_unit_type(flg_.current_gender());
image = utg.image() + get_RC_suffix(utg.flag_rgb(), color_);
image = utg.image() + ng::get_RC_suffix(utg.flag_rgb(), color_);
}
for(std::vector<std::string>::const_iterator itor = recruit_list.begin();
@ -349,7 +349,7 @@ void wait::join_game(bool observe)
const bool saved_game =
level_.child("multiplayer")["savegame"].to_bool();
flg_manager flg(era_factions, *side_choice, lock_settings, use_map_settings,
ng::flg_manager flg(era_factions, *side_choice, lock_settings, use_map_settings,
saved_game, color);
std::vector<std::string> choices;
@ -561,7 +561,7 @@ void wait::generate_menu()
leader_image = utg.image() + std::string("~RC(") + utg.flag_rgb() + ">" + RCcolor + ")";
#endif
} else {
leader_image = random_enemy_picture;
leader_image = ng::random_enemy_picture;
}
if (!leader_image.empty()) {
// Dumps the "image" part of the faction name, if any,

4
src/multiplayer_wait.hpp
View file

@ -43,7 +43,7 @@ private:
class leader_preview_pane : public gui::preview_pane
{
public:
leader_preview_pane(game_display& disp, flg_manager& flg,
leader_preview_pane(game_display& disp, ng::flg_manager& flg,
const int color);
bool show_above() const;
@ -56,7 +56,7 @@ private:
virtual void process_event();
virtual void draw_contents();
flg_manager& flg_;
ng::flg_manager& flg_;
const int color_;

8
src/playcampaign.cpp
View file

@ -36,7 +36,7 @@
#include "map_exception.hpp"
#include "mp_game_utils.hpp"
#include "multiplayer.hpp"
#include "multiplayer_connect_engine.hpp"
#include "connect_engine.hpp"
#include "dialogs.hpp"
#include "gettext.hpp"
#include "resources.hpp"
@ -389,8 +389,8 @@ LEVEL_RESULT play_game(game_display& disp, saved_game& gamestate,
gamestate.mp_settings().saved_game = false;
gamestate.mp_settings().use_map_settings = starting_pos["force_lock_settings"].to_bool();
mp::connect_engine_ptr
connect_engine(new mp::connect_engine(gamestate,
ng::connect_engine_ptr
connect_engine(new ng::connect_engine(gamestate,
!network_game, false));
if (allow_new_game_flag || (game_config::debug && network::nconnections() == 0)) {
@ -405,7 +405,7 @@ LEVEL_RESULT play_game(game_display& disp, saved_game& gamestate,
} else {
// Start the next scenario immediately.
connect_engine->
start_game(mp::connect_engine::FORCE_IMPORT_USERS);
start_game(ng::connect_engine::FORCE_IMPORT_USERS);
}
}
else if (io_type == IO_NONE && gamestate.valid())

5
src/saved_game.cpp
View file

@ -199,7 +199,10 @@ void saved_game::expand_scenario()
{
resources::config_manager->load_game_config_for_game(this->classification());
const config& game_config = resources::config_manager->game_config();
const config& scenario = game_config.find_child(lexical_cast_default<std::string> (classification().campaign_type), "id", carryover_sides_start["next_scenario"]);
const config& scenario = game_config.find_child(lexical_cast_default<std::string>
(classification().campaign_type == game_classification::SCENARIO ?
game_classification::MULTIPLAYER : classification().campaign_type),
"id", carryover_sides_start["next_scenario"]);
if(scenario)
{
this->starting_pos_type_ = STARTINGPOS_SCENARIO;

4
src/settings.cpp
View file

@ -39,9 +39,9 @@ int get_turns(const std::string& value)
(value, turns_default, turns_min, turns_max);
}
int get_village_gold(const std::string& value)
int get_village_gold(const std::string& value, game_classification::CAMPAIGN_TYPE gametype)
{
return lexical_cast_in_range<int>(value, 2, 1, 5);
return lexical_cast_in_range<int>(value, (gametype == game_classification::SCENARIO ? 1 : 2), 1, 5);
}
int get_village_support(const std::string& value)

4
src/settings.hpp
View file

@ -21,6 +21,7 @@
#define SETTINGS_HPP_INCLUDED
#include <string>
#include "game_classification.hpp"
/**
* Contains the general settings which have a default.
@ -49,6 +50,7 @@ namespace settings {
/**
* Gets the village gold.
* If no valid value supplied, it will return a default.
* The default is 1 for singleplayer, and 2 for multiplayer.
* The value is also range checked.
* When out of bounds, it will be set to the nearest bound.
*
@ -56,7 +58,7 @@ namespace settings {
*
* @returns the village gold
*/
int get_village_gold(const std::string& value);
int get_village_gold(const std::string& value, game_classification::CAMPAIGN_TYPE gametype = game_classification::MULTIPLAYER);
/**
* Gets the village unit level support.

133
src/singleplayer.cpp Normal file
View file

@ -0,0 +1,133 @@
#include "singleplayer.hpp"
#include "game_config_manager.hpp"
#include "gui/dialogs/campaign_selection.hpp"
#include "gui/dialogs/message.hpp"
#include "gui/widgets/window.hpp"
#include "resources.hpp"
namespace sp {
bool enter_create_mode(game_display& disp, const config& game_config,
saved_game& state, jump_to_campaign_info jump_to_campaign, bool local_players_only) {
bool configure_canceled = false;
do {
ng::create_engine create_eng(disp, state);
create_eng.set_current_level_type(ng::level::SP_CAMPAIGN);
std::vector<ng::create_engine::level_ptr> campaigns(
create_eng.get_levels_by_type_unfiltered(ng::level::SP_CAMPAIGN));
if (campaigns.empty()) {
gui2::show_error_message(disp.video(),
_("No campaigns are available.\n"));
return false;
}
int campaign_num = -1;
bool use_deterministic_mode = false;
// No campaign selected from command line
if (jump_to_campaign.campaign_id_.empty() == true)
{
gui2::tcampaign_selection dlg(campaigns);
try {
dlg.show(disp.video());
} catch(twml_exception& e) {
e.show(disp);
return false;
}
if(dlg.get_retval() != gui2::twindow::OK) {
return false;
}
campaign_num = dlg.get_choice();
use_deterministic_mode = dlg.get_deterministic();
}
else
{
// don't reset the campaign_id_ so we can know
// if we should quit the game or return to the main menu
// checking for valid campaign name
for(size_t i = 0; i < campaigns.size(); ++i)
{
if (campaigns[i]->data()["id"] == jump_to_campaign.campaign_id_)
{
campaign_num = i;
break;
}
}
// didn't found any campaign with that id
if (campaign_num == -1)
{
std::cerr<<"No such campaign id to jump to: ["<<jump_to_campaign.campaign_id_<<"]\n";
return false;
}
}
create_eng.set_current_level(campaign_num);
std::string random_mode = use_deterministic_mode ? "deterministic" : "";
state.carryover_sides_start["random_mode"] = random_mode;
state.classification().random_mode = random_mode;
std::string selected_difficulty = create_eng.select_campaign_difficulty(jump_to_campaign.difficulty_);
if (selected_difficulty == "FAIL") return false;
if (selected_difficulty == "CANCEL") {
if (jump_to_campaign.campaign_id_.empty() == false)
{
jump_to_campaign.campaign_id_ = "";
}
// canceled difficulty dialog, relaunch the campaign selection dialog
return enter_create_mode(disp, game_config, state, jump_to_campaign, local_players_only);
}
create_eng.prepare_for_campaign(selected_difficulty);
if (jump_to_campaign.scenario_id_.empty())
state.carryover_sides_start["next_scenario"] = create_eng.current_level().data()["id"].str();
else {
state.carryover_sides_start["next_scenario"] = jump_to_campaign.scenario_id_;
create_eng.current_level().set_data(
resources::config_manager->game_config().find_child(
lexical_cast<std::string> (game_classification::MULTIPLAYER),
"id", jump_to_campaign.scenario_id_));
}
create_eng.prepare_for_new_level();
state.mp_settings().mp_era = "era_blank";
configure_canceled = !enter_configure_mode(disp, resources::config_manager->game_config(), state, local_players_only);
} while (configure_canceled);
return true;
}
bool enter_configure_mode(game_display& disp, const config& game_config,
saved_game& state, bool local_players_only) {
ng::configure_engine engine(state);
engine.set_default_values();
return enter_connect_mode(disp, game_config, state, local_players_only);
}
bool enter_connect_mode(game_display&, const config&,
saved_game& state, bool local_players_only) {
ng::connect_engine engine(state, local_players_only, true);
engine.start_game();
return true;
}
} // end namespace sp

36
src/singleplayer.hpp Normal file
View file

@ -0,0 +1,36 @@
/*
Copyright (C) 2014 by Nathan Walker <nathan.b.walker@vanderbilt.edu>
Part of the Battle for Wesnoth Project http://www.wesnoth.org/
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY.
See the COPYING file for more details.
*/
#ifndef SINGLEPLAYER_HPP_INCLUDED
#define SINGLEPLAYER_HPP_INCLUDED
#include "game_launcher.hpp"
#include "create_engine.hpp"
#include "configure_engine.hpp"
#include "connect_engine.hpp"
namespace sp {
bool enter_create_mode(game_display& disp, const config& game_config,
saved_game& state, jump_to_campaign_info jump_to, bool local_players_only = true);
bool enter_configure_mode(game_display& disp, const config& game_config,
saved_game& state, bool local_players_only = true);
bool enter_connect_mode(game_display& disp, const config& game_config,
saved_game& state, bool local_players_only = true);
} // end namespace sp
#endif

29
src/tests/gui/test_gui2.cpp
View file

@ -55,8 +55,8 @@
#include "gui/dialogs/mp_connect.hpp"
#include "gui/dialogs/mp_create_game.hpp"
#include "gui/dialogs/mp_create_game_set_password.hpp"
#include "gui/dialogs/mp_depcheck_confirm_change.hpp"
#include "gui/dialogs/mp_depcheck_select_new.hpp"
#include "gui/dialogs/depcheck_confirm_change.hpp"
#include "gui/dialogs/depcheck_select_new.hpp"
#include "gui/dialogs/mp_login.hpp"
#include "gui/dialogs/mp_method_selection.hpp"
#include "gui/dialogs/simple_item_selector.hpp"
@ -72,6 +72,7 @@
#include "gui/widgets/settings.hpp"
#include "gui/widgets/window.hpp"
#include "language.hpp"
#include "create_engine.hpp"
#include "tests/utils/fake_display.hpp"
#include "video.hpp"
#include "wml_exception.hpp"
@ -397,8 +398,8 @@ BOOST_AUTO_TEST_CASE(test_gui2)
test<gui2::tmp_connect>();
test<gui2::tmp_create_game>();
test<gui2::tmp_create_game_set_password>();
test<gui2::tmp_depcheck_confirm_change>();
test<gui2::tmp_depcheck_select_new>();
test<gui2::tdepcheck_confirm_change>();
test<gui2::tdepcheck_select_new>();
test<gui2::tmp_login>();
test<gui2::tmp_method_selection>();
test<gui2::tmp_server_list>();
@ -500,9 +501,11 @@ struct twrapper<gui2::tcampaign_selection>
{
static const config::const_child_itors &ci =
main_config.child_range("campaign");
static std::vector<config> campaigns(ci.first, ci.second);
return new gui2::tcampaign_selection(campaigns);
static std::vector<ng::create_engine::level_ptr> levels;
BOOST_FOREACH(const config& campaign_cfg, ci) {
levels.push_back(ng::create_engine::level_ptr(new ng::campaign(campaign_cfg)));
}
return new gui2::tcampaign_selection(levels);
}
};
@ -714,22 +717,22 @@ struct twrapper<gui2::tmp_create_game_set_password>
};
template<>
struct twrapper<gui2::tmp_depcheck_confirm_change>
struct twrapper<gui2::tdepcheck_confirm_change>
{
static gui2::tmp_depcheck_confirm_change* create()
static gui2::tdepcheck_confirm_change* create()
{
static std::vector<std::string> mods = boost::assign::list_of("mod_one")("some other")("more");
return new gui2::tmp_depcheck_confirm_change(true, mods, "requester");
return new gui2::tdepcheck_confirm_change(true, mods, "requester");
}
};
template<>
struct twrapper<gui2::tmp_depcheck_select_new>
struct twrapper<gui2::tdepcheck_select_new>
{
static gui2::tmp_depcheck_select_new* create()
static gui2::tdepcheck_select_new* create()
{
static std::vector<std::string> mods = boost::assign::list_of("mod_one")("some other")("more");
return new gui2::tmp_depcheck_select_new(mp::depcheck::MODIFICATION, mods);
return new gui2::tdepcheck_select_new(ng::depcheck::MODIFICATION, mods);
}
};

94
src/tests/test_mp_connect.cpp
View file

@ -38,10 +38,10 @@ public:
{}
};*/
class test_mp_connect_engine : public mp::connect_engine {
class test_connect_engine : public ng::connect_engine {
public:
test_mp_connect_engine(game_display& /*disp*/, saved_game& gamestate) :
mp::connect_engine(gamestate, true, true)
test_connect_engine(game_display& /*disp*/, saved_game& gamestate) :
ng::connect_engine(gamestate, true, true)
{}
};
@ -100,21 +100,21 @@ struct mp_connect_fixture {
/* Test classes creation utilities */
static test_mp_connect_engine* create_test_mp_connect_engine()
static test_connect_engine* create_test_connect_engine()
{
test_mp_connect_engine* mp_connect_engine =
new test_mp_connect_engine(*disp, *state);
test_connect_engine* connect_engine =
new test_connect_engine(*disp, *state);
return mp_connect_engine;
return connect_engine;
}
static mp::side_engine* create_mp_side_engine(const config& defaults,
test_mp_connect_engine* connect_engine)
static ng::side_engine* create_side_engine(const config& defaults,
test_connect_engine* connect_engine)
{
config side_cfg = connect_engine->current_config()->child("side");
side_cfg.append(defaults);
return new mp::side_engine(side_cfg, *connect_engine, 0);
return new ng::side_engine(side_cfg, *connect_engine, 0);
}
@ -129,15 +129,15 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
// Set up side_engine and its dependencies.
state->mp_settings().use_map_settings = true;
state->mp_settings().saved_game = false;
boost::scoped_ptr<test_mp_connect_engine>
connect_engine(create_test_mp_connect_engine());
mp::side_engine_ptr side_engine;
boost::scoped_ptr<test_connect_engine>
connect_engine(create_test_connect_engine());
ng::side_engine_ptr side_engine;
config side;
// Recruit list with no faction.
side.clear();
side["recruit"] = "Elvish Archer";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_factions().size(), 1 );
//BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Custom" );
BOOST_CHECK_EQUAL( side_engine->new_config()["recruit"], "Elvish Archer" );
@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
// Custom faction, no recruits.
side.clear();
side["faction"] = "Custom";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_factions().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Custom" );
BOOST_CHECK_EQUAL( side_engine->new_config()["recruit"].empty(), true );
@ -153,21 +153,21 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
// Random faction.
side.clear();
side["faction"] = "Random";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_factions().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Random" );
// Valid faction.
side.clear();
side["faction"] = "Rebels";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_factions().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Rebels" );
// Invalid faction.
side.clear();
side["faction"] = "ThisFactionDoesNotExist";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK( side_engine->flg().choosable_factions().size() > 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Random" );
@ -175,7 +175,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
side.clear();
side["recruit"] = "Elvish Archer";
side["faction"] = "Undead";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_factions().size(), 1 );
//BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Custom" );
//BOOST_CHECK_EQUAL( side_engine->new_config()["recruit"], "Elvish Archer" );
@ -183,7 +183,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
// Carried over recruits.
side.clear();
side["previous_recruits"] = "Elvish Archer";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_factions().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Custom" );
BOOST_CHECK_EQUAL( side_engine->new_config()["previous_recruits"],
@ -192,7 +192,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
// Valid leader unit.
side.clear();
side["type"] = "Shadow";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_leaders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "Shadow" );
BOOST_CHECK_EQUAL( side_engine->new_config()["type"], "Shadow" );
@ -200,28 +200,28 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
// Invalid leader unit.
side.clear();
side["type"] = "ThisUnitDoesNotExist";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_leaders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "null" );
// No leader, Custom faction.
side.clear();
side["faction"] = "Custom";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK( side_engine->flg().choosable_leaders().size() > 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "random" );
// No leader, Random faction.
side.clear();
side["faction"] = "Random";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_leaders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "null" );
// No leader, regular faction.
side.clear();
side["faction"] = "Undead";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK( side_engine->flg().choosable_leaders().size() > 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "random" );
@ -232,34 +232,34 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
config& unit = side.add_child("unit");
unit["id"] = "LeaderID";
unit["type"] = "Elvish Ranger";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_leaders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "Elvish Ranger" );
// Random leader.
side.clear();
side["type"] = "random";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_leaders().size(), 1 );
// Leader with both genders.
side.clear();
side["type"] = "Elvish Archer";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_genders().size(), 3 );
BOOST_CHECK_EQUAL( side_engine->flg().current_gender(), "random" );
// Leader with only male gender.
side.clear();
side["type"] = "Swordsman";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_genders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_gender(), "male" );
// Leader with only female gender.
side.clear();
side["type"] = "Elvish Druid";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_genders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_gender(), "female" );
@ -267,7 +267,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
side.clear();
side["type"] = "White Mage";
side["gender"] = "female";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_genders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_gender(), "female" );
@ -275,7 +275,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
side.clear();
side["type"] = "Troll";
side["gender"] = "female";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_genders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_gender(), "male" );
@ -283,21 +283,21 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
side.clear();
side["type"] = "White Mage";
side["gender"] = "random";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
//BOOST_CHECK_EQUAL( side_engine->flg().choosable_genders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_gender(), "random" );
// No leader.
side.clear();
side["no_leader"] = true;
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK_EQUAL( side_engine->flg().choosable_leaders().size(), 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "null" );
// Resolve random faction.
side.clear();
side["faction"] = "Random";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
side_engine->resolve_random();
BOOST_CHECK( side_engine->flg().current_faction()["id"] != "Random" );
BOOST_CHECK( side_engine->flg().current_leader() != "random" &&
@ -309,7 +309,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
side.clear();
side["faction"] = "Random";
side["type"] = "Troll";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
side_engine->resolve_random();
BOOST_CHECK( side_engine->flg().current_faction()["id"] != "Random" );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "Troll" );
@ -321,7 +321,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
side["faction"] = "Random";
side["type"] = "White Mage";
side["gender"] = "male";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
side_engine->resolve_random();
BOOST_CHECK( side_engine->flg().current_faction()["id"] != "Random" );
BOOST_CHECK_EQUAL( side_engine->flg().current_leader(), "White Mage" );
@ -330,7 +330,7 @@ BOOST_AUTO_TEST_CASE( flg_map_settings )
// Resolve random leader.
side.clear();
side["type"] = "random";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
side_engine->resolve_random();
BOOST_CHECK( side_engine->flg().current_leader() != "random" );
}
@ -340,22 +340,22 @@ BOOST_AUTO_TEST_CASE( flg_no_map_settings )
// Set up side_engine and its dependencies.
state->mp_settings().use_map_settings = false;
state->mp_settings().saved_game = false;
boost::scoped_ptr<test_mp_connect_engine>
connect_engine(create_test_mp_connect_engine());
mp::side_engine_ptr side_engine;
boost::scoped_ptr<test_connect_engine>
connect_engine(create_test_connect_engine());
ng::side_engine_ptr side_engine;
config side;
// Recruit list with no faction.
side.clear();
side["recruit"] = "Elvish Archer";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK( side_engine->flg().choosable_factions().size() > 1 );
//BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Custom" );
// Custom faction, no recruits.
side.clear();
side["faction"] = "Custom";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK( side_engine->flg().choosable_factions().size() > 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Custom" );
BOOST_CHECK_EQUAL( side_engine->new_config()["recruit"].empty(), true );
@ -363,7 +363,7 @@ BOOST_AUTO_TEST_CASE( flg_no_map_settings )
// Carried over recruits.
side.clear();
side["previous_recruits"] = "Elvish Archer";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK( side_engine->flg().choosable_factions().size() > 1 );
BOOST_CHECK_EQUAL( side_engine->flg().current_faction()["id"], "Custom" );
BOOST_CHECK_EQUAL( side_engine->new_config()["previous_recruits"],
@ -372,7 +372,7 @@ BOOST_AUTO_TEST_CASE( flg_no_map_settings )
// Explicit leader for faction with multiple leaders.
side.clear();
side["type"] = "Goblin Impaler";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
side_engine->flg().set_current_faction("Rebels");
BOOST_CHECK( side_engine->flg().choosable_leaders().size() > 1 );
@ -380,7 +380,7 @@ BOOST_AUTO_TEST_CASE( flg_no_map_settings )
side.clear();
side["faction"] = "Custom";
side["type"] = "Swordsman";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
BOOST_CHECK( side_engine->flg().choosable_leaders().size() > 1 );
const std::vector<std::string>& leaders =
side_engine->flg().choosable_leaders();
@ -390,7 +390,7 @@ BOOST_AUTO_TEST_CASE( flg_no_map_settings )
// Explicit gender for unit with both genders available.
side.clear();
side["gender"] = "female";
side_engine.reset(create_mp_side_engine(side, connect_engine.get()));
side_engine.reset(create_side_engine(side, connect_engine.get()));
side_engine->flg().set_current_faction("Rebels");
side_engine->flg().set_current_leader("Elvish Ranger");
BOOST_CHECK_EQUAL( side_engine->flg().current_gender(), "random" );

1
src/wesnoth.cpp
View file

@ -677,6 +677,7 @@ static int do_gameloop(int argc, char** argv)
if(game->new_campaign() == false) {
continue;
}
should_reload = game_launcher::NO_RELOAD_DATA;
} else if(res == gui2::ttitle_screen::MULTIPLAYER) {
game_config::debug = game_config::mp_debug;
if(game->play_multiplayer() == false) {