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