The Battle for Wesnoth  1.15.1+dev
game.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2018 by David White <dave@whitevine.net>
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 "mt_rng.hpp"
18 #include "server/player.hpp"
20 #include "server/simple_wml.hpp"
21 #include "utils/make_enum.hpp"
22 
23 #include <boost/ptr_container/ptr_vector.hpp>
24 
25 #include <map>
26 #include <vector>
27 
28 // class player;
29 
30 namespace wesnothd
31 {
32 typedef std::vector<socket_ptr> user_vector;
33 typedef std::vector<socket_ptr> side_vector;
34 
35 class game
36 {
37 public:
38  MAKE_ENUM(CONTROLLER,
39  (HUMAN, "human")
40  (AI, "ai")
41  (EMPTY, "null")
42  )
43 
45  const socket_ptr& host,
46  const std::string& name = "",
47  bool save_replays = false,
48  const std::string& replay_save_path = "");
49 
50  ~game();
51 
52  int id() const
53  {
54  return id_;
55  }
56 
57  const std::string& name() const
58  {
59  return name_;
60  }
61 
62  bool is_owner(const socket_ptr& player) const
63  {
64  return (player == owner_);
65  }
66 
67  bool is_member(const socket_ptr& player) const
68  {
69  return is_player(player) || is_observer(player);
70  }
71 
72  bool allow_observers() const;
73  bool registered_users_only() const;
74  bool is_observer(const socket_ptr& player) const;
75  bool is_player(const socket_ptr& player) const;
76 
77  /** Checks whether the connection's ip address or username is banned. */
78  bool player_is_banned(const socket_ptr& player, const std::string& name) const;
79 
80  /** when the host sends the new scenario of a mp campaign */
81  void new_scenario(const socket_ptr& player);
82 
83  bool level_init() const
84  {
85  return level_.child("snapshot") || level_.child("scenario");
86  }
87 
89  {
90  if(simple_wml::node* scenario = data.child("scenario")) {
91  return scenario;
92  } else if(simple_wml::node* snapshot = data.child("snapshot")) {
93  return snapshot;
94  }
95 
96  return &data;
97  }
98 
99  static const simple_wml::node* starting_pos(const simple_wml::node& data)
100  {
101  if(const simple_wml::node* scenario = data.child("scenario")) {
102  return scenario;
103  } else if(const simple_wml::node* snapshot = data.child("snapshot")) {
104  return snapshot;
105  }
106 
107  return &data;
108  }
109 
111  {
112  return starting_pos(level_.root())->children("side");
113  }
114 
115  bool started() const
116  {
117  return started_;
118  }
119 
120  std::size_t nplayers() const
121  {
122  return players_.size();
123  }
124 
125  std::size_t nobservers() const
126  {
127  return observers_.size();
128  }
129 
130  std::size_t current_turn() const
131  {
132  return current_turn_;
133  }
134 
135  void set_current_turn(int turn)
136  {
137  current_turn_ = turn;
138  }
139 
140  std::string get_replay_filename();
141 
142  void mute_all_observers();
143 
144  /**
145  * Mute an observer or give a message of all currently muted observers if no
146  * name is given.
147  */
148  void mute_observer(const simple_wml::node& mute, const socket_ptr& muter);
149 
150  void unmute_observer(const simple_wml::node& unmute, const socket_ptr& unmuter);
151 
152  /**
153  * Kick a member by name.
154  *
155  * @return The network handle of the removed member if
156  * successful, null pointer otherwise.
157  */
158  socket_ptr kick_member(const simple_wml::node& kick, const socket_ptr& kicker);
159 
160  /**
161  * Ban and kick a user by name.
162  *
163  * The user does not need to be in this game but logged in.
164  *
165  * @return The network handle of the banned player if he
166  * was in this game, null pointer otherwise.
167  */
168  socket_ptr ban_user(const simple_wml::node& ban, const socket_ptr& banner);
169 
170  void unban_user(const simple_wml::node& unban, const socket_ptr& unbanner);
171 
172  /**
173  * Add a user to the game.
174  *
175  * @return True iff the user successfully joined the game.
176  */
177  bool add_player(const socket_ptr& player, bool observer = false);
178 
179  /**
180  * Removes a user from the game.
181  *
182  * @return True iff the game ends. That is, if there are
183  * no more players or the host left on a not yet
184  * started game.
185  */
186  bool remove_player(const socket_ptr& player, const bool disconnect = false, const bool destruct = false);
187 
188  /** Adds players and observers into one vector and returns that. */
189  const user_vector all_game_users() const;
190 
191  void start_game(const socket_ptr& starter);
192 
193  // this is performed just before starting and before [start_game] signal
194  // send scenario_diff's specific to each client so that they locally
195  // control their human sides
197 
198  void update_game();
199 
200  /** A user (player only?) asks for the next scenario to advance to. */
201  void load_next_scenario(const socket_ptr& user); // const
202 
203  // iceiceice: I unmarked this const because I want to send and record server messages when I fail to tweak sides
204  // properly
205 
206  /** Resets the side configuration according to the scenario data. */
207  void update_side_data();
208 
209  /** Let's a player owning a side give it to another player or observer. */
210  void transfer_side_control(const socket_ptr& sock, const simple_wml::node& cfg);
211 
212  void process_message(simple_wml::document& data, const socket_ptr& user);
213 
214  /**
215  * Handles [end_turn], repackages [commands] with private [speak]s in them
216  * and sends the data.
217  * Also filters commands from all but the current player.
218  * Currently removes all commands but [speak] for observers and all but
219  * [speak], [label] and [rename] for players.
220  *
221  * @returns True if the turn ended.
222  */
223  bool process_turn(simple_wml::document& data, const socket_ptr& user);
224 
225  /** Handles incoming [whiteboard] data. */
226  void process_whiteboard(simple_wml::document& data, const socket_ptr& user);
227  /** Handles incoming [change_turns_wml] data. */
229 
230  /**
231  * Set the description to the number of available slots.
232  *
233  * @returns True iff the number of slots has changed.
234  */
235  bool describe_slots();
236 
237  void send_server_message_to_all(const char* message, const socket_ptr& exclude = socket_ptr()) const;
238  void send_server_message_to_all(const std::string& message, const socket_ptr& exclude = socket_ptr()) const
239  {
240  send_server_message_to_all(message.c_str(), exclude);
241  }
242 
243  void send_server_message(
244  const char* message, const socket_ptr& sock = socket_ptr(), simple_wml::document* doc = nullptr) const;
246  const std::string& message, const socket_ptr& sock = socket_ptr(), simple_wml::document* doc = nullptr) const
247  {
248  send_server_message(message.c_str(), sock, doc);
249  }
250 
251  /** Send data to all players in this game except 'exclude'. */
252  void send_and_record_server_message(const char* message, const socket_ptr& exclude = socket_ptr());
253  void send_and_record_server_message(const std::string& message, const socket_ptr& exclude = socket_ptr())
254  {
255  send_and_record_server_message(message.c_str(), exclude);
256  }
257 
258  void send_data(
259  simple_wml::document& data, const socket_ptr& exclude = socket_ptr(), std::string packet_type = "") const;
260 
261  void clear_history();
262  void record_data(simple_wml::document* data);
263  void save_replay();
264 
265  /** The full scenario data. */
267  {
268  return level_;
269  }
270 
271  /**
272  * Functions to set/get the address of the game's summary description as
273  * sent to players in the lobby.
274  */
275  void set_description(simple_wml::node* desc);
276 
278  {
279  return description_;
280  }
281 
282  void set_password(const std::string& passwd)
283  {
284  password_ = passwd;
285  }
286 
287  void set_name_bans(const std::vector<std::string> name_bans)
288  {
289  name_bans_ = name_bans;
290  }
291 
292  bool password_matches(const std::string& passwd) const
293  {
294  return password_.empty() || passwd == password_;
295  }
296 
297  const std::string& termination_reason() const
298  {
299  static const std::string aborted = "aborted";
300  static const std::string not_started = "not started";
301 
302  return started_ ? (termination_.empty() ? aborted : termination_) : not_started;
303  }
304 
305  void set_termination_reason(const std::string& reason);
306 
307  void handle_choice(const simple_wml::node& data, const socket_ptr& user);
308 
309  void handle_random_choice(const simple_wml::node& data);
310 
311  void handle_controller_choice(const simple_wml::node& data);
312 
314  {
316  }
317 
318  /**
319  * Function which returns true iff 'player' controls any of the sides spcified in 'sides'.
320  */
321  bool controls_side(const std::vector<int>& sides, const socket_ptr& player) const;
322 
323 private:
324  // forbidden operations
325  game(const game&) = delete;
326  void operator=(const game&) = delete;
327 
328  std::size_t current_side() const
329  {
330  return nsides_ ? (current_side_index_ % nsides_) : 0;
331  }
332 
334  {
335  return (nsides_ ? sides_[current_side()] : socket_ptr());
336  }
337 
338  bool is_current_player(const socket_ptr& player) const
339  {
340  return (current_player() == player);
341  }
342 
343  bool is_muted_observer(const socket_ptr& player) const;
344  bool all_observers_muted() const
345  {
346  return all_observers_muted_;
347  }
348 
349  void send_muted_observers(const socket_ptr& user) const;
350 
351  bool send_taken_side(simple_wml::document& cfg, const simple_wml::node* side) const;
352 
353  /**
354  * Figures out which side to take and tells that side to the game owner.
355  *
356  * The owner then should send a [scenario_diff] that implements the side
357  * change and a subsequent update_side_data() call makes it actually
358  * happen.
359  * First we look for a side where save_id= or current_player= matches the
360  * new user's name then we search for the first controller="network" side.
361  */
362  bool take_side(const socket_ptr& user);
363 
364  /**
365  * Send [change_controller] message to tell all clients the new controller's name
366  * or controller type (human or ai).
367  */
368  void change_controller(const std::size_t side_num,
369  const socket_ptr& sock,
370  const std::string& player_name,
371  const bool player_left = true);
372  void transfer_ai_sides(const socket_ptr& player);
373  void send_leave_game(const socket_ptr& user) const;
374 
375  /**
376  @param sides a comma sperated list of side numbers to which the package should be sent,
377  */
379  const simple_wml::string_span& sides,
380  const socket_ptr& exclude = socket_ptr(),
381  std::string packet_type = "") const;
382 
383  void send_data_observers(
384  simple_wml::document& data, const socket_ptr& exclude = socket_ptr(), std::string packet_type = "") const;
385 
386  /**
387  * Send [observer] tags of all the observers in the game to the user or
388  * everyone if none given.
389  */
390  void send_observerjoins(const socket_ptr& sock = socket_ptr()) const;
391  void send_observerquit(const socket_ptr& observer) const;
392  void send_history(const socket_ptr& sock) const;
393 
394  /** In case of a host transfer, notify the new host about its status. */
395  void notify_new_host();
396 
397  /** Shortcut to a convenience function for finding a user by name. */
399 
400  bool observers_can_label() const
401  {
402  return false;
403  }
404 
405  bool observers_can_chat() const
406  {
407  return true;
408  }
409 
410  bool is_legal_command(const simple_wml::node& command, const socket_ptr& user);
411 
412  /**
413  * Checks whether a user has the same IP as any other members of this game.
414  * @return A comma separated string of members with matching IPs.
415  */
416  std::string has_same_ip(const socket_ptr& user) const;
417 
418  /**
419  * Function which should be called every time a player ends their turn
420  * (i.e. [end_turn] received). This will update the 'turn' attribute for
421  * the game's description when appropriate. Will return true iff there has
422  * been a change.
423  */
424  bool end_turn(int new_side);
425 
426  void update_turn_data();
427  /**
428  * Function to send a list of users to all clients.
429  *
430  * Only sends data if the game is initialized but not yet started.
431  */
432  void send_user_list(const socket_ptr& exclude = socket_ptr()) const;
433 
434  /** Returns the name of the user or "(unfound)". */
435  std::string username(const socket_ptr& pl) const;
436 
437  /** Returns a comma separated list of user names. */
438  std::string list_users(user_vector users, const std::string& func) const;
439 
440  /** Function to log when we don't find a connection in player_info_. */
441  void missing_user(socket_ptr socket, const std::string& func) const;
442 
443  /** calculates the initial value for sides_, side_controllerds_, nsides_*/
444  void reset_sides();
445 
446  /** Helps debugging player and observer lists. */
447  std::string debug_player_info() const;
448 
449  /** Helps debugging controller tweaks. */
450  std::string debug_sides_info() const;
451 
453 
454  static int id_num;
455  int id_;
456 
457  /** The name of the game. */
458  std::string name_;
459  std::string password_;
460 
461  /** The game host or later owner (if the host left). */
463 
464  /** A vector of players (members owning a side). */
465  user_vector players_;
466 
467  /** A vector of observers (members not owning a side). */
468  user_vector observers_;
469  user_vector muted_observers_;
470 
471  /** A vector of side owners. */
472  side_vector sides_;
473 
474  std::vector<CONTROLLER> side_controllers_;
475 
476  /** Number of sides in the current scenario. */
477  int nsides_;
478  bool started_;
479 
480  /**
481  The current scenario data.ยด
482  WRONG! This contains the initial state or the state from which
483  the game was loaded from.
484  Using this to make assumptions about the current gamestate is
485  extremely dangerous and should especially not be done for anything
486  that can be nodified by wml (especially by [modify_side]),
487  like team_name, controller ... in [side].
488  FIXME: move every code here that uses this object to query those
489  information to the clients. But note that there are some checks
490  (like controller == null) that are definitely needed by the server and
491  in this case we should try to modify the client to inform the server if
492  a change of those properties occur. Ofc we shouldn't update level_
493  then, but rather store that information in a separate object
494  (like in side_controllers_).
495  */
497 
498  /** Replay data. */
499  typedef boost::ptr_vector<simple_wml::document> history;
500  mutable history history_;
501 
502  /** Pointer to the game's description in the games_and_users_list_. */
504 
509 
510  // IP ban list and name ban list
511  std::vector<std::string> bans_;
512  std::vector<std::string> name_bans_;
513  /// in multiplayer campaigns it can happen that some players are still in the previousl scenario
514  /// keep track of those players because processing certain
515  /// input from those side wil lead to error (oos)
516  std::set<socket_ptr> players_not_advanced_;
517 
518  std::string termination_;
519 
521  std::string replay_save_path_;
522 
523  /** A wrapper for mersenne twister rng which generates randomness for this game */
526 };
527 
528 } // namespace wesnothd
bool remove_player(const socket_ptr &player, const bool disconnect=false, const bool destruct=false)
Removes a user from the game.
Definition: game.cpp:1468
void send_data(simple_wml::document &data, const socket_ptr &exclude=socket_ptr(), std::string packet_type="") const
Definition: game.cpp:1673
bool save_replays_
Definition: game.hpp:520
bool started() const
Definition: game.hpp:115
void set_current_turn(int turn)
Definition: game.hpp:135
void missing_user(socket_ptr socket, const std::string &func) const
Function to log when we don&#39;t find a connection in player_info_.
Definition: game.cpp:88
void update_game()
Definition: game.cpp:374
const socket_ptr & host
Definition: game.hpp:45
void new_scenario(const socket_ptr &player)
when the host sends the new scenario of a mp campaign
Definition: game.cpp:1610
const std::string & name() const
Definition: game.hpp:57
bool observers_can_label() const
Definition: game.hpp:400
void save_replay()
Definition: game.cpp:1836
MAKE_ENUM(CONTROLLER,(HUMAN, "human")(AI, "ai")(EMPTY, "null")) game(player_connections &player_connections
player_connections & player_connections_
Definition: game.hpp:452
void send_server_message_to_all(const std::string &message, const socket_ptr &exclude=socket_ptr()) const
Definition: game.hpp:238
void handle_random_choice(const simple_wml::node &data)
Definition: game.cpp:1150
void send_history(const socket_ptr &sock) const
Definition: game.cpp:1779
void change_controller(const std::size_t side_num, const socket_ptr &sock, const std::string &player_name, const bool player_left=true)
Send [change_controller] message to tell all clients the new controller&#39;s name or controller type (hu...
Definition: game.cpp:623
const simple_wml::node::child_list & get_sides_list() const
Definition: game.hpp:110
void send_and_record_server_message(const std::string &message, const socket_ptr &exclude=socket_ptr())
Definition: game.hpp:253
bool player_is_banned(const socket_ptr &player, const std::string &name) const
Checks whether the connection&#39;s ip address or username is banned.
Definition: game.cpp:707
user_vector muted_observers_
Definition: game.hpp:469
void update_side_data()
Resets the side configuration according to the scenario data.
Definition: game.cpp:455
void send_and_record_server_message(const char *message, const socket_ptr &exclude=socket_ptr())
Send data to all players in this game except &#39;exclude&#39;.
Definition: game.cpp:1999
const socket_ptr const std::string bool save_replays
Definition: game.hpp:47
std::vector< socket_ptr > side_vector
Definition: game.hpp:33
void send_server_message(const std::string &message, const socket_ptr &sock=socket_ptr(), simple_wml::document *doc=nullptr) const
Definition: game.hpp:245
void process_whiteboard(simple_wml::document &data, const socket_ptr &user)
Handles incoming [whiteboard] data.
Definition: game.cpp:1278
bool level_init() const
Definition: game.hpp:83
std::size_t current_side() const
Definition: game.hpp:328
int nsides_
Number of sides in the current scenario.
Definition: game.hpp:477
user_vector observers_
A vector of observers (members not owning a side).
Definition: game.hpp:468
void send_server_message(const char *message, const socket_ptr &sock=socket_ptr(), simple_wml::document *doc=nullptr) const
Definition: game.cpp:2019
socket_ptr find_user(const simple_wml::string_span &name)
Shortcut to a convenience function for finding a user by name.
Definition: game.cpp:1989
bool all_observers_muted_
Definition: game.hpp:508
bool is_observer(const socket_ptr &player) const
Definition: game.cpp:176
std::string termination_
Definition: game.hpp:518
void send_leave_game(const socket_ptr &user) const
Definition: game.cpp:811
randomness::mt_rng rng_
A wrapper for mersenne twister rng which generates randomness for this game.
Definition: game.hpp:524
void send_server_message_to_all(const char *message, const socket_ptr &exclude=socket_ptr()) const
Definition: game.cpp:2012
history history_
Definition: game.hpp:500
const socket_ptr current_player() const
Definition: game.hpp:333
std::string username(const socket_ptr &pl) const
Returns the name of the user or "(unfound)".
Definition: game.cpp:199
std::vector< std::string > bans_
Definition: game.hpp:511
game(const game &)=delete
Definition: game.cpp:94
node * child(const char *name)
Definition: simple_wml.hpp:260
node * child(const char *name)
Definition: simple_wml.cpp:606
bool process_turn(simple_wml::document &data, const socket_ptr &user)
Handles [end_turn], repackages [commands] with private [speak]s in them and sends the data...
Definition: game.cpp:1002
void process_message(simple_wml::document &data, const socket_ptr &user)
Definition: game.cpp:921
void process_change_turns_wml(simple_wml::document &data, const socket_ptr &user)
Handles incoming [change_turns_wml] data.
Definition: game.cpp:1305
int last_choice_request_id_
Definition: game.hpp:525
bool password_matches(const std::string &passwd) const
Definition: game.hpp:292
void start_game(const socket_ptr &starter)
Definition: game.cpp:295
bool end_turn(int new_side)
Function which should be called every time a player ends their turn (i.e.
Definition: game.cpp:1334
void reset_sides()
calculates the initial value for sides_, side_controllerds_, nsides_
Definition: game.cpp:444
std::vector< CONTROLLER > side_controllers_
Definition: game.hpp:474
int num_turns_
Definition: game.hpp:507
void update_turn_data()
Definition: game.cpp:1366
bool allow_observers() const
Definition: game.cpp:166
void handle_controller_choice(const simple_wml::node &data)
Definition: game.cpp:1171
bool describe_slots()
Set the description to the number of available slots.
Definition: game.cpp:676
boost::ptr_vector< simple_wml::document > history
Replay data.
Definition: game.hpp:499
void load_next_scenario(const socket_ptr &user)
A user (player only?) asks for the next scenario to advance to.
Definition: game.cpp:1621
std::string get_replay_filename()
Definition: game.cpp:1826
void send_observerjoins(const socket_ptr &sock=socket_ptr()) const
Send [observer] tags of all the observers in the game to the user or everyone if none given...
Definition: game.cpp:1747
std::size_t nobservers() const
Definition: game.hpp:125
const user_vector all_game_users() const
Adds players and observers into one vector and returns that.
Definition: game.cpp:1925
std::string has_same_ip(const socket_ptr &user) const
Checks whether a user has the same IP as any other members of this game.
Definition: game.cpp:1728
void perform_controller_tweaks()
Definition: game.cpp:230
bool add_player(const socket_ptr &player, bool observer=false)
Add a user to the game.
Definition: game.cpp:1384
bool is_player(const socket_ptr &player) const
Definition: game.cpp:194
std::string list_users(user_vector users, const std::string &func) const
Returns a comma separated list of user names.
Definition: game.cpp:209
void transfer_ai_sides(const socket_ptr &player)
bool all_observers_muted() const
Definition: game.hpp:344
bool observers_can_chat() const
Definition: game.hpp:405
void send_observerquit(const socket_ptr &observer) const
Definition: game.cpp:1767
socket_ptr kick_member(const simple_wml::node &kick, const socket_ptr &kicker)
Kick a member by name.
Definition: game.cpp:817
socket_ptr owner_
The game host or later owner (if the host left).
Definition: game.hpp:462
static simple_wml::node * starting_pos(simple_wml::node &data)
Definition: game.hpp:88
void send_user_list(const socket_ptr &exclude=socket_ptr()) const
Function to send a list of users to all clients.
Definition: game.cpp:1583
static const simple_wml::node * starting_pos(const simple_wml::node &data)
Definition: game.hpp:99
std::vector< std::string > name_bans_
Definition: game.hpp:512
void send_muted_observers(const socket_ptr &user) const
Definition: game.cpp:725
std::vector< node * > child_list
Definition: simple_wml.hpp:124
void unban_user(const simple_wml::node &unban, const socket_ptr &unbanner)
Definition: game.cpp:891
bool take_side(const socket_ptr &user)
Figures out which side to take and tells that side to the game owner.
Definition: game.cpp:403
const socket_ptr const std::string bool const std::string & replay_save_path
Definition: game.hpp:48
bool is_current_player(const socket_ptr &player) const
Definition: game.hpp:338
std::size_t current_turn() const
Definition: game.hpp:130
void reset_last_synced_context_id()
Definition: game.hpp:313
bool is_legal_command(const simple_wml::node &command, const socket_ptr &user)
Definition: game.cpp:937
void send_data_observers(simple_wml::document &data, const socket_ptr &exclude=socket_ptr(), std::string packet_type="") const
void mute_observer(const simple_wml::node &mute, const socket_ptr &muter)
Mute an observer or give a message of all currently muted observers if no name is given...
Definition: game.cpp:737
int current_side_index_
Definition: game.hpp:506
void record_data(simple_wml::document *data)
Definition: game.cpp:1892
side_vector sides_
A vector of side owners.
Definition: game.hpp:472
void notify_new_host()
In case of a host transfer, notify the new host about its status.
Definition: game.cpp:665
void handle_choice(const simple_wml::node &data, const socket_ptr &user)
Definition: game.cpp:1236
void set_description(simple_wml::node *desc)
Functions to set/get the address of the game&#39;s summary description as sent to players in the lobby...
Definition: game.cpp:1903
void set_password(const std::string &passwd)
Definition: game.hpp:282
std::string observer
std::size_t nplayers() const
Definition: game.hpp:120
simple_wml::node * description_
Pointer to the game&#39;s description in the games_and_users_list_.
Definition: game.hpp:503
std::string name_
The name of the game.
Definition: game.hpp:458
std::string debug_sides_info() const
Helps debugging controller tweaks.
Definition: game.cpp:1969
void operator=(const game &)=delete
bool is_owner(const socket_ptr &player) const
Definition: game.hpp:62
static int id_num
Definition: game.hpp:454
void unmute_observer(const simple_wml::node &unmute, const socket_ptr &unmuter)
Definition: game.cpp:779
void send_data_sides(simple_wml::document &data, const simple_wml::string_span &sides, const socket_ptr &exclude=socket_ptr(), std::string packet_type="") const
Definition: game.cpp:1698
bmi::multi_index_container< player_record, bmi::indexed_by< bmi::ordered_unique< bmi::tag< socket_t >, bmi::const_mem_fun< player_record, const socket_ptr, &player_record::socket > >, bmi::hashed_unique< bmi::tag< name_t >, bmi::const_mem_fun< player_record, const std::string &, &player_record::name > >, bmi::ordered_non_unique< bmi::tag< game_t >, bmi::const_mem_fun< player_record, int, &player_record::game_id > > > > player_connections
Definition: ban.cpp:28
const std::string & termination_reason() const
Definition: game.hpp:297
std::string replay_save_path_
Definition: game.hpp:521
int current_turn_
Definition: game.hpp:505
user_vector players_
A vector of players (members owning a side).
Definition: game.hpp:465
std::vector< socket_ptr > user_vector
Definition: game.hpp:32
bool is_muted_observer(const socket_ptr &player) const
Definition: game.cpp:181
void transfer_side_control(const socket_ptr &sock, const simple_wml::node &cfg)
Let&#39;s a player owning a side give it to another player or observer.
Definition: game.cpp:527
std::shared_ptr< boost::asio::ip::tcp::socket > socket_ptr
Definition: server_base.hpp:30
std::string password_
Definition: game.hpp:459
bool started_
Definition: game.hpp:478
bool send_taken_side(simple_wml::document &cfg, const simple_wml::node *side) const
Definition: game.cpp:382
std::set< socket_ptr > players_not_advanced_
in multiplayer campaigns it can happen that some players are still in the previousl scenario keep tra...
Definition: game.hpp:516
std::string debug_player_info() const
Helps debugging player and observer lists.
Definition: game.cpp:1935
void set_name_bans(const std::vector< std::string > name_bans)
Definition: game.hpp:287
bool is_member(const socket_ptr &player) const
Definition: game.hpp:67
bool controls_side(const std::vector< int > &sides, const socket_ptr &player) const
Function which returns true iff &#39;player&#39; controls any of the sides spcified in &#39;sides&#39;.
Definition: game.cpp:1715
Defines the MAKE_ENUM macro.
simple_wml::document level_
The current scenario data.
Definition: game.hpp:496
void clear_history()
Definition: game.cpp:1898
void mute_all_observers()
Definition: game.cpp:715
void set_termination_reason(const std::string &reason)
Definition: game.cpp:1911
socket_ptr ban_user(const simple_wml::node &ban, const socket_ptr &banner)
Ban and kick a user by name.
Definition: game.cpp:849
bool registered_users_only() const
Definition: game.cpp:171
simple_wml::document & level()
The full scenario data.
Definition: game.hpp:266
simple_wml::node * description() const
Definition: game.hpp:277
int id() const
Definition: game.hpp:52