The Battle for Wesnoth  1.17.0-dev
connect_engine.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2013 - 2021
3  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 2 of the License, or
8  (at your option) any later version.
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY.
11 
12  See the COPYING file for more details.
13 */
14 
15 #pragma once
16 
17 #include "commandline_options.hpp"
18 #include "config.hpp"
19 #include "flg_manager.hpp"
20 #include "saved_game.hpp"
21 #include <set>
22 
23 namespace randomness { class mt_rng; }
24 struct mp_game_metadata;
25 class game_config_view;
26 
27 namespace ng {
28 
29 enum controller {
35 };
36 
37 class connect_engine;
39 
40 typedef std::shared_ptr<side_engine> side_engine_ptr;
41 typedef std::pair<ng::controller, std::string> controller_option;
42 
44 {
45 public:
47  const bool first_scenario, mp_game_metadata* metadata);
48 
49  config* current_config();
50 
51  void import_user(const std::string& name, const bool observer,
52  int side_taken = -1);
53  void import_user(const config& data, const bool observer,
54  int side_taken = -1);
55 
56  // Returns true if there are still sides available for this game.
57  bool sides_available() const;
58 
59  // Import all sides into the level.
60  void update_level();
61  // Updates the level and sends a diff to the clients.
62  void update_and_send_diff(bool update_time_of_day = false);
63 
64  bool can_start_game() const;
65  void start_game();
66  void start_game_commandline(const commandline_options& cmdline_opts, const game_config_view& game_config);
67 
68  void leave_game();
69 
70  // Return pair first element specifies whether to leave the game
71  // and second element whether to silently update UI.
72  std::pair<bool, bool> process_network_data(const config& data);
73 
74  // Returns the side which is taken by a given user,
75  // or -1 if none was found.
76  int find_user_side_index_by_id(const std::string& id) const;
77 
78 
79  /* Setters & Getters */
80 
81  const config& level() const { return level_; }
83  {
84  if(config& scenario = level_.child("scenario"))
85  return scenario;
86  else if(config& snapshot = level_.child("snapshot"))
87  return snapshot;
88  else
89  throw "No scenariodata found";
90  }
91  const std::set<std::string>& connected_users() const;
92 
94  {
95  std::string team_name;
96  std::string user_team_name; // TODO: use t_string?
97 
99  };
100 
101  const std::vector<team_data_pod>& team_data() const
102  {
103  return team_data_;
104  }
105 
106  std::vector<side_engine_ptr>& side_engines() { return side_engines_; }
107  const mp_game_settings& params() const { return params_; }
108  bool first_scenario() const { return first_scenario_; }
109  bool force_lock_settings() const { return force_lock_settings_; }
110 
111 private:
112  connect_engine(const connect_engine&) = delete;
113  connect_engine& operator=(const connect_engine&) = delete;
114 
115  void send_level_data() const;
116 
117  void save_reserved_sides_information();
118  void load_previous_sides_users();
119 
120  void update_side_controller_options();
121 
122  friend class side_engine;
123 
126 
128 
131  const bool first_scenario_;
132 
134 
135  std::vector<side_engine_ptr> side_engines_;
136  std::vector<const config*> era_factions_;
137  std::vector<team_data_pod> team_data_;
138 
139  std::set<std::string>& connected_users_rw();
140  void send_to_server(const config& cfg) const;
141 };
142 
144 {
145 public:
146  side_engine(const config& cfg, connect_engine& parent_engine,
147  const int index);
148 
149  // An untranslated user_description which is used by other clients
150  // An empty string means the other clients should generate the description on their own
151  // Used by new_config().
152  std::string user_description() const;
153 
154  // Creates a config representing this side.
155  config new_config() const;
156 
157  // Returns true, if the player has chosen his/her leader and this side
158  // is ready for the game to start.
159  bool ready_for_start() const;
160  // Returns true if this side is waiting for a network player and
161  // players are allowed.
162  bool available_for_user(const std::string& name = "") const;
163 
164  void resolve_random( randomness::mt_rng & rng, const std::vector<std::string> & avoid_faction_ids = std::vector<std::string>());
165 
166  // Resets this side to its default state.
167  void reset();
168 
169  // Place user into this side.
170  void place_user(const std::string& name);
171  void place_user(const config& data, bool contains_selection = false);
172 
173  void update_controller_options();
174  void update_current_controller_index();
175  bool controller_changed(const int selection);
176  void set_controller(ng::controller controller);
177 
178  // Game set up from command line helpers.
179  void set_faction_commandline(const std::string& faction_name);
180  void set_controller_commandline(const std::string& controller_name);
181 
182  /* Setters & Getters */
183 
184  std::string save_id() const
185  { return (!cfg_["save_id"].empty()) ? cfg_["save_id"] : cfg_["id"]; }
186  // The id of the side of the previous scenario that should control this side.
187  std::string previous_save_id() const
188  { return (!cfg_["previous_save_id"].empty()) ? cfg_["previous_save_id"] : save_id(); }
189  const std::vector<controller_option>& controller_options() const
190  { return controller_options_; }
191  const config& cfg() const { return cfg_; }
192  ng::controller controller() const { return controller_; }
193  unsigned current_controller_index() const
194  { return current_controller_index_; }
195  int index() const { return index_; }
196  void set_index(int index) { index_ = index; }
197  unsigned team() const { return team_; }
198  void set_team(unsigned team) { team_ = team; }
199  std::multimap<std::string, config> get_side_children();
200  void set_side_children(std::multimap<std::string, config> children);
201  int color() const { return color_; }
202  void set_color(int color) { color_ = color; color_id_ = color_options_[color]; }
203  int gold() const { return gold_; }
204  void set_gold(int gold) { gold_ = gold; }
205  int income() const { return income_; }
206  void set_income(int income) { income_ = income; }
207  const std::string& player_id() const { return player_id_; }
208  const std::string& reserved_for() const { return reserved_for_; }
209  void set_reserved_for(const std::string& reserved_for)
210  { reserved_for_ = reserved_for; }
211  const std::string& ai_algorithm() const { return ai_algorithm_; }
212  void set_ai_algorithm(const std::string& ai_algorithm)
213  { ai_algorithm_ = ai_algorithm; }
214  bool allow_player() const { return allow_player_; }
215  bool allow_changes() const { return allow_changes_; }
216  bool waiting_to_choose_faction() const { return waiting_to_choose_faction_; }
217  void set_waiting_to_choose_status(bool status) { waiting_to_choose_faction_ = status;}
218  bool allow_shuffle() const { return !disallow_shuffle_;}
219  flg_manager& flg() { return flg_; }
220 
221  const std::string color_id() const { return color_id_; }
222  const std::vector<std::string>& color_options() const { return color_options_; }
223 
224  const std::string team_name() const
225  {
226  return parent_.team_data_[team_].team_name;
227  }
228 
229  const std::string user_team_name() const
230  {
231  return t_string::from_serialized(parent_.team_data_[team_].user_team_name);
232  }
233 
234 private:
235  side_engine(const side_engine& engine) = delete;
236  side_engine& operator=(const side_engine&) = delete;
237 
238  friend class connect_engine;
239 
240  void add_controller_option(ng::controller controller,
241  const std::string& name, const std::string& controller_value);
242 
245 
248  std::vector<controller_option> controller_options_;
249 
250  const bool allow_player_;
251  const bool controller_lock_;
252 
253  int index_;
254  unsigned team_;
255  int color_;
256  int gold_;
257  int income_;
258  // set during create_engines constructor never set after that.
259  // the name of the player who is preferred for this side,
260  // if controller_ == reserved only this player can take this side.
261  // can also be a number of a side if this side should be controlled
262  // by the player who controls that side
263  std::string reserved_for_;
264  std::string player_id_;
265  std::string ai_algorithm_;
266 
270  const bool allow_changes_;
272 
273  std::vector<std::string> color_options_;
274 
275  std::string color_id_;
276 };
277 
278 } // end namespace ng
flg_manager & flg()
int income() const
config & child(config_key_type key, int n=0)
Returns the nth child with the given key, or a reference to an invalid config if there is none...
Definition: config.cpp:417
void set_waiting_to_choose_status(bool status)
void set_reserved_for(const std::string &reserved_for)
std::vector< side_engine_ptr > side_engines_
std::string save_id() const
void set_income(int income)
bool force_lock_settings() const
std::string ai_algorithm_
std::string player_id_
bool allow_changes() const
std::vector< team_data_pod > team_data_
const bool allow_changes_
FLG stands for faction, leader and gender.
Definition: flg_manager.hpp:28
const std::vector< team_data_pod > & team_data() const
std::vector< controller_option > controller_options_
Definitions for the interface to Wesnoth Markup Language (WML).
void set_color(int color)
mp_game_metadata * mp_metadata_
This class stores all the data for a single &#39;side&#39; (in game nomenclature).
Definition: team.hpp:71
std::vector< side_engine_ptr > & side_engines()
std::string ready_for_start
const std::string & reserved_for() const
const std::string & player_id() const
const std::string team_name() const
const std::string & ai_algorithm() const
const mp_game_settings & params() const
std::vector< std::string > color_options_
void set_gold(int gold)
const bool first_scenario_
ng::controller controller_
const std::string color_id() const
std::vector< const config * > era_factions_
const ng::controller default_controller_
Game configuration data as global variables.
Definition: build_info.cpp:58
bool allow_shuffle() const
void set_ai_algorithm(const std::string &ai_algorithm)
std::string reserved_for_
static t_string from_serialized(const std::string &string)
Definition: tstring.hpp:153
bool allow_player() const
const config & level() const
std::size_t index(const std::string &str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
Definition: unicode.cpp:69
unsigned current_controller_index_
connect_engine & parent_
std::string observer
std::shared_ptr< side_engine > side_engine_ptr
const std::string user_team_name() const
std::pair< ng::controller, std::string > controller_option
void set_index(int index)
std::string previous_save_id() const
const bool controller_lock_
const config & cfg() const
const mp_game_settings & params_
bool first_scenario() const
std::string color_id_
const std::vector< controller_option > & controller_options() const
ng::controller controller() const
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:59
const bool allow_player_
bool waiting_to_choose_faction() const
unsigned current_controller_index() const
static std::string controller_name(const team &t)
Definition: game_stats.cpp:68
void set_team(unsigned team)
const std::vector< std::string > & color_options() const
unsigned team() const