The Battle for Wesnoth  1.19.0-dev
game.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2024
3  by David White <dave@whitevine.net>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 #pragma once
17 
18 #include "mt_rng.hpp"
22 #include "side_controller.hpp"
23 
24 #include <map>
25 #include <optional>
26 #include <vector>
27 
28 // class player;
29 
30 namespace wesnothd
31 {
32 typedef std::vector<player_iterator> user_vector;
33 typedef std::vector<std::optional<player_iterator>> side_vector;
34 class server;
35 
36 class game
37 {
38 public:
40  player_iterator host,
41  const std::string& name = "",
42  bool save_replays = false,
43  const std::string& replay_save_path = "");
44 
45  ~game();
46 
47  /**
48  * This ID is reused between scenarios of MP campaigns.
49  * This ID resets when wesnothd is restarted.
50  * This is generally used when needing to find a particular running game.
51  * @return an ID that uniquely identifies the game within the currently running wesnothd instance.
52  */
53  int id() const
54  {
55  return id_;
56  }
57 
58  /**
59  * This ID is not reused between scenarios of MP campaigns.
60  * This ID resets when wesnothd is restarted.
61  * This is generally used during database queries.
62  *
63  * @return an ID that uniquely identifies the game within the currently running wesnothd instance.
64  */
65  int db_id() const
66  {
67  return db_id_;
68  }
69 
70  /**
71  * Increments the ID used when running database queries.
72  */
73  void next_db_id()
74  {
75  db_id_ = db_id_num++;
76  }
77 
78  /**
79  * @return The game's name.
80  */
81  const std::string& name() const
82  {
83  return name_;
84  }
85 
86  /**
87  * @param player The player being checked.
88  * @return Whether the provided player is the game's owner(host).
89  */
91  {
92  return (player == owner_);
93  }
94 
95  /**
96  * @param player The player being checked.
97  * @return Whether the provided player has joined the game.
98  */
100  {
101  return is_player(player) || is_observer(player);
102  }
103 
104  /**
105  * @return Whether observers are allowed to join.
106  */
107  bool allow_observers() const;
108 
109  /**
110  * @param player The player being checked.
111  * @return Whether the provided player is an observer of this game.
112  */
113  bool is_observer(player_iterator player) const;
114 
115  /**
116  * @param player The player being checked.
117  * @return Whether the provided player is playing this game (aka owns one or more sides).
118  */
119  bool is_player(player_iterator player) const;
120 
121  /**
122  * @param player The player being checked (by iterator).
123  * @param name The player being checked (by username).
124  * @return Whether the connection's ip address or username is banned from this game.
125  */
126  bool player_is_banned(player_iterator player, const std::string& name) const;
127 
128  /**
129  * When the host sends the new scenario of a mp campaign
130  *
131  * @param sender The player sending the scenario data.
132  */
133  void new_scenario(player_iterator sender);
134 
135  /**
136  * @return Whether this game contains scenario data and thus has been initialized.
137  */
138  bool level_init() const
139  {
140  return level_.child("snapshot") || level_.child("scenario");
141  }
142 
143  /**
144  * The non-const version.
145  *
146  * @param data The data describing the level for a game.
147  * @return The [scenario] child node if it exists, else the [snapshot] child if it exists, else @a data.
148  */
150  {
151  if(simple_wml::node* scenario = data.child("scenario")) {
152  return scenario;
153  } else if(simple_wml::node* snapshot = data.child("snapshot")) {
154  return snapshot;
155  }
156 
157  return &data;
158  }
159 
160  /**
161  * The const version.
162  *
163  * @param data The data describing the level for a game.
164  * @return The [scenario] child node if it exists, else the [snapshot] child if it exists, else @a data.
165  */
167  {
168  if(const simple_wml::node* scenario = data.child("scenario")) {
169  return scenario;
170  } else if(const simple_wml::node* snapshot = data.child("snapshot")) {
171  return snapshot;
172  }
173 
174  return &data;
175  }
176 
177  /**
178  * @return The nodes containing the sides in this game.
179  */
181  {
182  return starting_pos(level_.root())->children("side");
183  }
184 
185  /**
186  * @return Whether this game has started yet.
187  */
188  bool started() const
189  {
190  return started_;
191  }
192 
193  /**
194  * @return The number of players. One player can have multiple sides.
195  */
196  std::size_t nplayers() const
197  {
198  return players_.size();
199  }
200 
201  /**
202  * @return The number of observers in this game.
203  */
204  std::size_t nobservers() const
205  {
206  return observers_.size();
207  }
208 
209  /**
210  * @return This game's current turn.
211  */
212  std::size_t current_turn() const
213  {
214  return current_turn_;
215  }
216 
217  /**
218  * @return The name of the replay for this game.
219  */
220  std::string get_replay_filename();
221 
222  /** Toggles whether all observers are muted or not. */
223  void mute_all_observers();
224 
225  /**
226  * Mute an observer or give a message of all currently muted observers if no name is given.
227  *
228  * @param mute The observer to mute. Empty if sending a message to muted observers.
229  * @param muter The player doing the muting.
230  */
231  void mute_observer(const simple_wml::node& mute, player_iterator muter);
232 
233  /**
234  * Unmute an observer or unmute all currently muted observers if no name is given.
235  *
236  * @param unmute The observer to unmute. Empty if unmuting all observers.
237  * @param unmuter The player doing the unmuting.
238  */
239  void unmute_observer(const simple_wml::node& unmute, player_iterator unmuter);
240 
241  /**
242  * Kick a user from this game by name.
243  *
244  * @param kick The user to kick.
245  * @param kicker The player doing the kicking.
246  * @return The iterator to the removed member if successful, empty optional otherwise.
247  */
248  std::optional<player_iterator> kick_member(const simple_wml::node& kick, player_iterator kicker);
249 
250  /**
251  * Ban a user by name.
252  *
253  * The user does not need to be in this game but logged in.
254  *
255  * @param ban The user to ban.
256  * @param banner The player doing the banning.
257  * @return The iterator to the banned player if he was in this game, empty optional otherwise.
258  */
259  std::optional<player_iterator> ban_user(const simple_wml::node& ban, player_iterator banner);
260 
261  /**
262  * Unban a user by name.
263  *
264  * The user does not need to be in this game but logged in.
265  *
266  * @param unban The user to unban.
267  * @param unbanner The player doing the unbanning.
268  */
269  void unban_user(const simple_wml::node& unban, player_iterator unbanner);
270 
271  /**
272  * Add a user to the game.
273  *
274  * @todo differentiate between "observers not allowed" and "player already in the game" errors.
275  * maybe return a string with an error message.
276  *
277  * @param player The player to add.
278  * @param observer Whether to add the player as an observer.
279  * @return True if the user successfully joined the game, false otherwise.
280  */
281  bool add_player(player_iterator player, bool observer = false);
282 
283  /**
284  * Removes a user from the game.
285  *
286  * @param player The player to remove.
287  * @param disconnect If the player disconnected from the server entirely.
288  * @param destruct If the game is ending as well.
289  * @return True if the player's removal ends the game. That is, if there are no more players or the host left on a not yet started game.
290  */
291  bool remove_player(player_iterator player, const bool disconnect = false, const bool destruct = false);
292 
293  /**
294  * @return A vector containing all players and observers currently in this game.
295  */
296  const user_vector all_game_users() const;
297 
298  /**
299  * Starts the game (if a new game) or starts the next scenario of an MP campaign.
300  * @param starter The game's host.
301  */
302  void start_game(player_iterator starter);
303 
304  /**
305  * This is performed just before starting and before the [start_game] signal.
306  * Sends [scenario_diff]s specific to each client so that they locally control their human sides.
307  */
309 
310  /**
311  * A user asks for the next scenario to advance to.
312  *
313  * @param user The user asking for the next scenario.
314  */
316 
317  /** Resets the side configuration according to the scenario data. */
318  void update_side_data();
319 
320  /**
321  * Lets a player owning a side give it to another player or observer.
322  *
323  * @param player The player owning the side.
324  * @param cfg The node containing the transfer information.
325  */
327 
328  /**
329  * Sends an ingame message to all other players.
330  *
331  * @param data The message to send.
332  * @param user The user sending the message.
333  */
335 
336  /**
337  * Handles [end_turn], repackages [commands] with private [speak]s in them
338  * and sends the data.
339  * Also filters commands from all but the current player.
340  * Currently removes all commands but [speak] for observers and all but
341  * [speak], [label], and [rename] for players.
342  *
343  * @param data The turn commands.
344  * @param user The user who sent a command to be processed during the turn. This may not be the player whose turn it currently is.
345  * @returns True if the turn ended.
346  */
348 
349  /**
350  * Handles incoming [whiteboard] data.
351  *
352  * @param data The whiteboard data.
353  * @param user The user sending the whiteboard data.
354  */
356 
357  /**
358  * Handles incoming [change_turns_wml] data.
359  *
360  * @param data The [change_turns_wml] data.
361  * @param user The player changing turns.
362  */
364 
365  /**
366  * Set the description to the number of available slots.
367  *
368  * @returns True if the number of slots has changed.
369  */
370  bool describe_slots();
371 
372  /**
373  * Sends a message to all players in this game that aren't excluded.
374  *
375  * @param message The message to send.
376  * @param exclude The players to not send the message to.
377  */
378  void send_server_message_to_all(const char* message, std::optional<player_iterator> exclude = {});
379  /**
380  * @ref send_server_message_to_all
381  */
382  void send_server_message_to_all(const std::string& message, std::optional<player_iterator> exclude = {})
383  {
384  send_server_message_to_all(message.c_str(), exclude);
385  }
386 
387  /**
388  * Send a server message to the specified player.
389  *
390  * @param message The message to send.
391  * @param player The player to send the message to. If empty then the message is not sent.
392  * @param doc The document to create the message in. If nullptr then a new document is created.
393  */
394  void send_server_message(
395  const char* message, std::optional<player_iterator> player = {}, simple_wml::document* doc = nullptr) const;
396  /**
397  * @ref send_server_message
398  */
400  const std::string& message, std::optional<player_iterator> player = {}, simple_wml::document* doc = nullptr) const
401  {
402  send_server_message(message.c_str(), player, doc);
403  }
404 
405  /**
406  * Send data to all players in this game except 'exclude'.
407  * Also record this data for the replay.
408  *
409  * @param message The message to send.
410  * @param exclude The players to not send the message to.
411  */
412  void send_and_record_server_message(const char* message, std::optional<player_iterator> exclude = {});
413  /**
414  * @ref send_and_record_server_message
415  */
416  void send_and_record_server_message(const std::string& message, std::optional<player_iterator> exclude = {})
417  {
418  send_and_record_server_message(message.c_str(), exclude);
419  }
420 
421  /**
422  * Send data to all players except those excluded.
423  * For example, to send a message to all players except the player who typed the original message.
424  *
425  * @param data The data to send.
426  * @param players The players to send the data to.
427  * @param exclude The player from @a players to not send the data to.
428  */
429  template<typename Container>
430  void send_to_players(simple_wml::document& data, const Container& players, std::optional<player_iterator> exclude = {});
431 
432  /**
433  * Send data to all players and observers except those excluded.
434  *
435  * @param data The data to send.
436  * @param exclude The players/observers to not send the data to.
437  */
438  void send_data(simple_wml::document& data, std::optional<player_iterator> exclude = {});
439 
440  /**
441  * Clears the history of recorded WML documents.
442  */
443  void clear_history();
444 
445  /**
446  * Clears the history of recorded chat WML documents.
447  */
448  void clear_chat_history();
449 
450  /**
451  * Records a WML document in the game's history.
452  *
453  * @param data The WML document to record.
454  */
455  void record_data(std::unique_ptr<simple_wml::document> data);
456 
457  /**
458  * Move the level information and recorded history into a replay file and save it.
459  */
460  void save_replay();
461 
462  /**
463  * @return The full scenario data.
464  */
466  {
467  return level_;
468  }
469 
470  /**
471  * Set the game's description.
472  * Also set the game as requiring a password if a password is set.
473  *
474  * @param desc The node containing the game's description.
475  */
476  void set_description(simple_wml::node* desc);
477 
478  /**
479  * @return The node containing the game's current description.
480  */
482  {
483  return description_;
484  }
485 
486  /**
487  * Sets the password required to access the game.
488  *
489  * @param passwd The password to set.
490  */
491  void set_password(const std::string& passwd)
492  {
493  password_ = passwd;
494  }
495 
496  /**
497  * Set a list of usernames that should all be banned from joining the game.
498  *
499  * @param name_bans The list of usernames.
500  */
501  void set_name_bans(const std::vector<std::string> name_bans)
502  {
503  name_bans_ = name_bans;
504  }
505 
506  /**
507  * @param passwd The password to join with.
508  * @return True if the game's password is empty or if the provided password matches, false otherwise.
509  */
510  bool password_matches(const std::string& passwd) const
511  {
512  return password_.empty() || passwd == password_;
513  }
514 
515  /**
516  * @return Whether the game has a password set.
517  */
518  bool has_password() const
519  {
520  return !password_.empty();
521  }
522 
523  /**
524  * Provides the reason the game was ended.
525  *
526  * @return Either that the game was aborted (after starting), not started, or has some other reason set.
527  */
528  const std::string& termination_reason() const
529  {
530  static const std::string aborted = "aborted";
531  static const std::string not_started = "not started";
532 
533  return started_ ? (termination_.empty() ? aborted : termination_) : not_started;
534  }
535 
536  /**
537  * Sets the termination reason for this game.
538  *
539  * @param reason The termination reason.
540  */
541  void set_termination_reason(const std::string& reason);
542 
543  /**
544  * Handle a choice requested by a client, such as changing a side's controller, if initiated by WML/lua.
545  *
546  * @param data The data needed to process the choice.
547  * @param user The player making the request.
548  */
550 
551  /**
552  * Send a randomly generated number to the requestor.
553  */
554  void handle_random_choice();
555 
556  /**
557  * Handle a request to change a side's controller.
558  * Note that this does not change who owns a side.
559  *
560  * @param data Contains the information about which side to change the controller of.
561  */
563 
564  /**
565  * Adds a new, empty side owned by no one.
566  */
567  void handle_add_side_wml();
568 
569  /**
570  * Reset the internal counter for choice requests made by clients to the server.
571  */
573  {
575  }
576 
577  /**
578  * Function which returns true if 'player' controls any of the sides specified in 'sides'.
579  *
580  * @param sides The list of sides in this game.
581  * @param player The player being checked for whether they own any sides.
582  */
583  bool controls_side(const std::vector<int>& sides, player_iterator player) const;
584 
585  /**
586  * @return Whether the loaded WML has the attribute indicating that this is a reloaded savegame rather than a brand new game.
587  */
588  bool is_reload() const;
589 
591  {
592  players_.clear();
593  observers_.clear();
594  }
595 
596 private:
597  // forbidden operations
598  game(const game&) = delete;
599  game& operator=(const game&) = delete;
600 
601  /**
602  * @return 0 if there are no sides, or the current side index otherwise.
603  */
604  std::size_t current_side() const
605  {
606  return nsides_ != 0 ? (current_side_index_ % nsides_) : 0;
607  }
608 
609  /**
610  * @return The player who owns the current side.
611  */
612  std::optional<player_iterator> current_player() const
613  {
614  return sides_[current_side()];
615  }
616 
617  /**
618  * @param player The player being checked.
619  * @return Whether the player being checked is the current player taking their turn.
620  */
622  {
623  return (current_player() == player);
624  }
625 
626  /**
627  * @param player The observer being checked.
628  * @return True if the observer is muted or if all observers are muted, false otherwise.
629  */
631 
632  /**
633  * @return True if all observers have been muted via that command (not if each individual observer happens to have been manually muted).
634  */
635  bool all_observers_muted() const
636  {
637  return all_observers_muted_;
638  }
639 
640  /**
641  * Sends a message either stating that all observers are muted or listing the observers that are muted.
642  *
643  * @param user The player to send the message to.
644  */
645  void send_muted_observers(player_iterator user) const;
646 
647  /**
648  * Tell the host who owns a side.
649  *
650  * @param cfg The document to send to the host.
651  * @param side The side information to send.
652  * @return True if the document was sent, false otherwise.
653  */
654  bool send_taken_side(simple_wml::document& cfg, const simple_wml::node* side) const;
655 
656  /**
657  * Figures out which side to take and tells that side to the game owner.
658  *
659  * The owner then should send a [scenario_diff] that implements the side
660  * change and a subsequent update_side_data() call makes it actually
661  * happen.
662  * First we look for a side where save_id= or current_player= matches the
663  * new user's name then we search for the first controller=human or reserved side.
664  *
665  * @param user The player taking a side.
666  * @return True if the side was taken, false otherwise.
667  */
668  bool take_side(player_iterator user);
669 
670  /**
671  * Send [change_controller] message to tell all clients the new controller's name or controller type (human or ai).
672  *
673  * @param side_index The index of the side whose controller is changing.
674  * @param player The player who is taking control of the side.
675  * @param player_name The name of the player who is taking control of the side.
676  * @param player_left We use the "player_left" field as follows. Normally change_controller sends one message to the owner, and one message to everyone else.
677  * In case that a player drops, the owner is gone and should not get a message, instead the host gets a [side_drop] message.
678  */
679  void change_controller(const std::size_t side_index,
681  const std::string& player_name,
682  const bool player_left = true);
683 
684  /**
685  * Tell everyone else but the source player that the controller type changed.
686  *
687  * @param side_index The index of the side whose controller type is changing.
688  * @param player The player who owns the side whose controller type is changing.
689  * @param player_name The name of the player who owns the side whose controller type is changing.
690  * @return The document that was sent to all other players.
691  */
692  std::unique_ptr<simple_wml::document> change_controller_type(const std::size_t side_index,
694  const std::string& player_name);
695 
696  /**
697  * Tells a player to leave the game.
698  *
699  * @param user The player leaving the game.
700  */
701  void send_leave_game(player_iterator user) const;
702 
703  /**
704  * Sends a document to the provided list of sides.
705  *
706  * @param data The data to be sent to the provided sides.
707  * @param sides A comma sperated list of side numbers to which the document should be sent.
708  * @param exclude Players to not send the data to.
709  */
711  const simple_wml::string_span& sides,
712  std::optional<player_iterator> exclude = {});
713 
714  /**
715  * Send a document per observer in the game.
716  * If @a player is blank, send these documents to everyone, else send them to just the observer who joined.
717  *
718  * @param player The observer who joined.
719  */
720  void send_observerjoins(std::optional<player_iterator> player = {});
722  void send_history(player_iterator sock) const;
723  void send_chat_history(player_iterator sock) const;
724 
725  /** In case of a host transfer, notify the new host about its status. */
726  void notify_new_host();
727 
728  /**
729  * Shortcut to a convenience function for finding a user by name.
730  *
731  * @param name The name of the user to find.
732  * @return The player if found, else empty.
733  */
734  std::optional<player_iterator> find_user(const simple_wml::string_span& name);
735 
736  bool is_legal_command(const simple_wml::node& command, player_iterator user);
737 
738  /**
739  * Checks whether a user has the same IP as any other members of this game.
740  * @return A comma separated string of members with matching IPs.
741  */
742  std::string has_same_ip(player_iterator user) const;
743 
744  /**
745  * Function which should be called every time a player ends their turn
746  * (i.e. [end_turn] received). This will update the 'turn' attribute for
747  * the game's description when appropriate.
748  *
749  * @param new_side The side number whose turn to move it has become.
750  * @return True if the current side and-or current turn values have been updated, false otherwise.
751  */
752  bool end_turn(int new_side);
753 
754  /**
755  * Set or update the current and max turn values in the game's description.
756  */
757  void update_turn_data();
758 
759  /**
760  * Function to send a list of users to all clients.
761  * Only sends data if the game is initialized but not yet started.
762  *
763  * @param exclude The players to not send the list of users to.
764  */
765  void send_user_list(std::optional<player_iterator> exclude = {});
766 
767  /**
768  * @param pl The player.
769  * @return The player's username.
770  */
771  std::string username(player_iterator pl) const;
772 
773  /**
774  * @param users The users to create a comma separated list from.
775  * @return A comma separated list of user names.
776  */
777  std::string list_users(user_vector users) const;
778 
779  /** calculates the initial value for sides_, side_controllerds_, nsides_*/
780  void reset_sides();
781 
782  /**
783  * Helps debugging player and observer lists.
784  *
785  * @return A string listing the game IDs, players, and observers.
786  */
787  std::string debug_player_info() const;
788 
789  /**
790  * Helps debugging controller tweaks.
791  *
792  * @return A string listing the game IDs and side information.
793  */
794  std::string debug_sides_info() const;
795 
796  /** The wesnothd server instance this game exists on. */
799 
800  /**
801  * Incremented to retrieve a unique ID for game instances within wesnothd.
802  */
803  static int id_num;
804  /** This game's ID within wesnothd */
805  int id_;
806 
807  /**
808  * Incremented to retrieve a unique ID per wesnothd instance for game instances within the database.
809  */
810  static int db_id_num;
811  /**
812  * Used for unique identification of games played in the database.
813  * Necessary since for MP campaigns multiple scenarios can be played within the same game instance
814  * and we need a unique ID per scenario played, not per game instance.
815  */
816  int db_id_;
817 
818  /** The name of the game. */
819  std::string name_;
820  /** The password needed to join the game. */
821  std::string password_;
822 
823  /** The game host or later owner (if the host left). */
825 
826  /** A vector of players (members owning a side). */
828 
829  /** A vector of observers (members not owning a side). */
831  /** A vector of muted observers. */
833 
834  /** A vector of side owners. */
836 
837  /** A vector containiner the controller type for each side. */
838  std::vector<side_controller::type> side_controllers_;
839 
840  /** Number of sides in the current scenario. */
841  int nsides_;
842  /** Whether the game has been started or not. */
843  bool started_;
844 
845  /**
846  The current scenario data.
847 
848  WRONG! This contains the initial state or the state from which
849  the game was loaded from.
850  Using this to make assumptions about the current gamestate is
851  extremely dangerous and should especially not be done for anything
852  that can be nodified by wml (especially by [modify_side]),
853  like team_name, controller ... in [side].
854 
855  FIXME: move every code here that uses this object to query those
856  information to the clients. But note that there are some checks
857  (like controller == null) that are definitely needed by the server and
858  in this case we should try to modify the client to inform the server if
859  a change of those properties occur. Ofc we shouldn't update level_
860  then, but rather store that information in a separate object
861  (like in side_controllers_).
862  */
864 
865  /** Replay data. */
866  mutable std::vector<std::unique_ptr<simple_wml::document>> history_;
867  /** Replay chat history data. */
868  mutable std::vector<std::unique_ptr<simple_wml::document>> chat_history_;
869 
870  /** Pointer to the game's description in the games_and_users_list_. */
872 
873  /** The game's current turn. */
875  /** The index of the current side. The side number is current_side_index_+1. */
877  /** The maximum number of turns before the game ends. */
879  /** Whether all observers should be treated as muted. */
881 
882  /** List of banned IPs */
883  std::vector<std::string> bans_;
884  /** List of banned usernames */
885  std::vector<std::string> name_bans_;
886 
887  /**
888  * in multiplayer campaigns it can happen that some players are still in the previous scenario
889  * keep track of those players because processing certain
890  * input from those side wil lead to error (oos)
891  */
892  std::set<const player_record*> players_not_advanced_;
893 
894  /** The reason the game ended. */
895  std::string termination_;
896 
897  /** Whether to save a replay of this game. */
899  /** Where to save the replay of this game. */
900  std::string replay_save_path_;
901 
902  /** A wrapper for mersenne twister rng which generates randomness for this game */
904  /**
905  * The ID of the last request received from a client.
906  * New requests should never have a lower value than this.
907  */
909 };
910 
911 } // namespace wesnothd
node * child(const char *name)
Definition: simple_wml.hpp:262
const child_list & children(const char *name) const
Definition: simple_wml.cpp:635
std::vector< node * > child_list
Definition: simple_wml.hpp:126
std::optional< player_iterator > ban_user(const simple_wml::node &ban, player_iterator banner)
Ban a user by name.
Definition: game.cpp:807
void handle_controller_choice(const simple_wml::node &data)
Handle a request to change a side's controller.
Definition: game.cpp:1143
std::string debug_player_info() const
Helps debugging player and observer lists.
Definition: game.cpp:1900
bool is_reload() const
Definition: game.cpp:1995
void mute_all_observers()
Toggles whether all observers are muted or not.
Definition: game.cpp:674
static const simple_wml::node * starting_pos(const simple_wml::node &data)
The const version.
Definition: game.hpp:166
int current_side_index_
The index of the current side.
Definition: game.hpp:876
std::vector< std::unique_ptr< simple_wml::document > > history_
Replay data.
Definition: game.hpp:866
bool is_legal_command(const simple_wml::node &command, player_iterator user)
Definition: game.cpp:891
void clear_chat_history()
Clears the history of recorded chat WML documents.
Definition: game.cpp:1863
void send_and_record_server_message(const char *message, std::optional< player_iterator > exclude={})
Send data to all players in this game except 'exclude'.
Definition: game.cpp:1945
std::vector< std::string > bans_
List of banned IPs.
Definition: game.hpp:883
bool is_owner(player_iterator player) const
Definition: game.hpp:90
void send_history(player_iterator sock) const
Definition: game.cpp:1728
std::optional< player_iterator > current_player() const
Definition: game.hpp:612
void process_change_turns_wml(simple_wml::document &data, player_iterator user)
Handles incoming [change_turns_wml] data.
Definition: game.cpp:1279
bool is_current_player(player_iterator player) const
Definition: game.hpp:621
randomness::mt_rng rng_
A wrapper for mersenne twister rng which generates randomness for this game.
Definition: game.hpp:903
std::string has_same_ip(player_iterator user) const
Checks whether a user has the same IP as any other members of this game.
Definition: game.cpp:1681
void send_server_message(const std::string &message, std::optional< player_iterator > player={}, simple_wml::document *doc=nullptr) const
send_server_message
Definition: game.hpp:399
std::string name_
The name of the game.
Definition: game.hpp:819
void notify_new_host()
In case of a host transfer, notify the new host about its status.
Definition: game.cpp:624
void send_data_sides(simple_wml::document &data, const simple_wml::string_span &sides, std::optional< player_iterator > exclude={})
Sends a document to the provided list of sides.
Definition: game.cpp:1652
void send_chat_history(player_iterator sock) const
Definition: game.cpp:1755
void update_side_data()
Resets the side configuration according to the scenario data.
Definition: game.cpp:401
std::string replay_save_path_
Where to save the replay of this game.
Definition: game.hpp:900
void send_leave_game(player_iterator user) const
Tells a player to leave the game.
Definition: game.cpp:769
void handle_random_choice()
Send a randomly generated number to the requestor.
Definition: game.cpp:1114
void set_termination_reason(const std::string &reason)
Sets the termination reason for this game.
Definition: game.cpp:1876
void unban_user(const simple_wml::node &unban, player_iterator unbanner)
Unban a user by name.
Definition: game.cpp:849
bool level_init() const
Definition: game.hpp:138
std::optional< player_iterator > find_user(const simple_wml::string_span &name)
Shortcut to a convenience function for finding a user by name.
Definition: game.cpp:1935
std::vector< std::unique_ptr< simple_wml::document > > chat_history_
Replay chat history data.
Definition: game.hpp:868
void perform_controller_tweaks()
This is performed just before starting and before the [start_game] signal.
Definition: game.cpp:196
void record_data(std::unique_ptr< simple_wml::document > data)
Records a WML document in the game's history.
Definition: game.cpp:1852
std::vector< side_controller::type > side_controllers_
A vector containiner the controller type for each side.
Definition: game.hpp:838
void handle_add_side_wml()
Adds a new, empty side owned by no one.
Definition: game.cpp:1136
void clear_history()
Clears the history of recorded WML documents.
Definition: game.cpp:1858
std::size_t nobservers() const
Definition: game.hpp:204
bool password_matches(const std::string &passwd) const
Definition: game.hpp:510
void send_to_players(simple_wml::document &data, const Container &players, std::optional< player_iterator > exclude={})
Send data to all players except those excluded.
Definition: game.cpp:1638
int current_turn_
The game's current turn.
Definition: game.hpp:874
bool save_replays_
Whether to save a replay of this game.
Definition: game.hpp:898
void send_muted_observers(player_iterator user) const
Sends a message either stating that all observers are muted or listing the observers that are muted.
Definition: game.cpp:684
void load_next_scenario(player_iterator user)
A user asks for the next scenario to advance to.
Definition: game.cpp:1585
bool started() const
Definition: game.hpp:188
bool add_player(player_iterator player, bool observer=false)
Add a user to the game.
Definition: game.cpp:1355
void new_scenario(player_iterator sender)
When the host sends the new scenario of a mp campaign.
Definition: game.cpp:1573
void send_server_message_to_all(const char *message, std::optional< player_iterator > exclude={})
Sends a message to all players in this game that aren't excluded.
Definition: game.cpp:1956
const user_vector all_game_users() const
Definition: game.cpp:1890
void start_game(player_iterator starter)
Starts the game (if a new game) or starts the next scenario of an MP campaign.
Definition: game.cpp:251
static simple_wml::node * starting_pos(simple_wml::node &data)
The non-const version.
Definition: game.hpp:149
std::vector< std::string > name_bans_
List of banned usernames.
Definition: game.hpp:885
game(wesnothd::server &server, player_connections &player_connections, player_iterator host, const std::string &name="", bool save_replays=false, const std::string &replay_save_path="")
Definition: game.cpp:77
bool remove_player(player_iterator player, const bool disconnect=false, const bool destruct=false)
Removes a user from the game.
Definition: game.cpp:1440
int id_
This game's ID within wesnothd.
Definition: game.hpp:805
simple_wml::document & level()
Definition: game.hpp:465
std::size_t current_side() const
Definition: game.hpp:604
bool process_turn(simple_wml::document &data, player_iterator user)
Handles [end_turn], repackages [commands] with private [speak]s in them and sends the data.
Definition: game.cpp:956
std::size_t current_turn() const
Definition: game.hpp:212
std::string username(player_iterator pl) const
Definition: game.cpp:176
void process_whiteboard(simple_wml::document &data, player_iterator user)
Handles incoming [whiteboard] data.
Definition: game.cpp:1252
player_connections & player_connections_
Definition: game.hpp:798
bool all_observers_muted() const
Definition: game.hpp:635
bool is_member(player_iterator player) const
Definition: game.hpp:99
int db_id_
Used for unique identification of games played in the database.
Definition: game.hpp:816
void reset_sides()
calculates the initial value for sides_, side_controllerds_, nsides_
Definition: game.cpp:390
std::optional< player_iterator > kick_member(const simple_wml::node &kick, player_iterator kicker)
Kick a user from this game by name.
Definition: game.cpp:775
void handle_choice(const simple_wml::node &data, player_iterator user)
Handle a choice requested by a client, such as changing a side's controller, if initiated by WML/lua.
Definition: game.cpp:1208
std::string list_users(user_vector users) const
Definition: game.cpp:181
user_vector muted_observers_
A vector of muted observers.
Definition: game.hpp:832
bool is_muted_observer(player_iterator player) const
Definition: game.cpp:158
std::set< const player_record * > players_not_advanced_
in multiplayer campaigns it can happen that some players are still in the previous scenario keep trac...
Definition: game.hpp:892
void save_replay()
Move the level information and recorded history into a replay file and save it.
Definition: game.cpp:1796
simple_wml::node * description() const
Definition: game.hpp:481
void transfer_side_control(player_iterator player, const simple_wml::node &cfg)
Lets a player owning a side give it to another player or observer.
Definition: game.cpp:473
void unmute_observer(const simple_wml::node &unmute, player_iterator unmuter)
Unmute an observer or unmute all currently muted observers if no name is given.
Definition: game.cpp:737
bool started_
Whether the game has been started or not.
Definition: game.hpp:843
int db_id() const
This ID is not reused between scenarios of MP campaigns.
Definition: game.hpp:65
void emergency_cleanup()
Definition: game.hpp:590
bool has_password() const
Definition: game.hpp:518
std::string debug_sides_info() const
Helps debugging controller tweaks.
Definition: game.cpp:1916
std::string termination_
The reason the game ended.
Definition: game.hpp:895
const std::string & name() const
Definition: game.hpp:81
void send_server_message(const char *message, std::optional< player_iterator > player={}, simple_wml::document *doc=nullptr) const
Send a server message to the specified player.
Definition: game.cpp:1963
void send_observerjoins(std::optional< player_iterator > player={})
Send a document per observer in the game.
Definition: game.cpp:1696
const simple_wml::node::child_list & get_sides_list() const
Definition: game.hpp:180
simple_wml::node * description_
Pointer to the game's description in the games_and_users_list_.
Definition: game.hpp:871
game(const game &)=delete
user_vector observers_
A vector of observers (members not owning a side).
Definition: game.hpp:830
static int db_id_num
Incremented to retrieve a unique ID per wesnothd instance for game instances within the database.
Definition: game.hpp:810
void set_description(simple_wml::node *desc)
Set the game's description.
Definition: game.cpp:1868
int num_turns_
The maximum number of turns before the game ends.
Definition: game.hpp:878
bool all_observers_muted_
Whether all observers should be treated as muted.
Definition: game.hpp:880
side_vector sides_
A vector of side owners.
Definition: game.hpp:835
int nsides_
Number of sides in the current scenario.
Definition: game.hpp:841
int id() const
This ID is reused between scenarios of MP campaigns.
Definition: game.hpp:53
void send_data(simple_wml::document &data, std::optional< player_iterator > exclude={})
Send data to all players and observers except those excluded.
Definition: game.cpp:1647
simple_wml::document level_
The current scenario data.
Definition: game.hpp:863
void set_name_bans(const std::vector< std::string > name_bans)
Set a list of usernames that should all be banned from joining the game.
Definition: game.hpp:501
bool take_side(player_iterator user)
Figures out which side to take and tells that side to the game owner.
Definition: game.cpp:349
void change_controller(const std::size_t side_index, player_iterator player, const std::string &player_name, const bool player_left=true)
Send [change_controller] message to tell all clients the new controller's name or controller type (hu...
Definition: game.cpp:576
bool allow_observers() const
Definition: game.cpp:148
user_vector players_
A vector of players (members owning a side).
Definition: game.hpp:827
void next_db_id()
Increments the ID used when running database queries.
Definition: game.hpp:73
void send_observerquit(player_iterator observer)
Definition: game.cpp:1716
bool send_taken_side(simple_wml::document &cfg, const simple_wml::node *side) const
Tell the host who owns a side.
Definition: game.cpp:328
wesnothd::server & server
The wesnothd server instance this game exists on.
Definition: game.hpp:797
void send_and_record_server_message(const std::string &message, std::optional< player_iterator > exclude={})
send_and_record_server_message
Definition: game.hpp:416
std::string password_
The password needed to join the game.
Definition: game.hpp:821
bool is_observer(player_iterator player) const
Definition: game.cpp:153
bool describe_slots()
Set the description to the number of available slots.
Definition: game.cpp:635
void reset_last_synced_context_id()
Reset the internal counter for choice requests made by clients to the server.
Definition: game.hpp:572
bool is_player(player_iterator player) const
Definition: game.cpp:171
int last_choice_request_id_
The ID of the last request received from a client.
Definition: game.hpp:908
const std::string & termination_reason() const
Provides the reason the game was ended.
Definition: game.hpp:528
void send_server_message_to_all(const std::string &message, std::optional< player_iterator > exclude={})
send_server_message_to_all
Definition: game.hpp:382
bool controls_side(const std::vector< int > &sides, player_iterator player) const
Function which returns true if 'player' controls any of the sides specified in 'sides'.
Definition: game.cpp:1668
void send_user_list(std::optional< player_iterator > exclude={})
Function to send a list of users to all clients.
Definition: game.cpp:1550
static int id_num
Incremented to retrieve a unique ID for game instances within wesnothd.
Definition: game.hpp:803
bool player_is_banned(player_iterator player, const std::string &name) const
Definition: game.cpp:666
std::string get_replay_filename()
Definition: game.cpp:1786
void set_password(const std::string &passwd)
Sets the password required to access the game.
Definition: game.hpp:491
void mute_observer(const simple_wml::node &mute, player_iterator muter)
Mute an observer or give a message of all currently muted observers if no name is given.
Definition: game.cpp:696
std::unique_ptr< simple_wml::document > change_controller_type(const std::size_t side_index, player_iterator player, const std::string &player_name)
Tell everyone else but the source player that the controller type changed.
Definition: game.cpp:608
void update_turn_data()
Set or update the current and max turn values in the game's description.
Definition: game.cpp:1340
game & operator=(const game &)=delete
bool end_turn(int new_side)
Function which should be called every time a player ends their turn (i.e.
Definition: game.cpp:1308
player_iterator owner_
The game host or later owner (if the host left).
Definition: game.hpp:824
void process_message(simple_wml::document &data, player_iterator user)
Sends an ingame message to all other players.
Definition: game.cpp:879
std::size_t nplayers() const
Definition: game.hpp:196
std::string observer
bool save_replays()
Definition: game.cpp:756
std::vector< player_iterator > user_vector
Definition: game.hpp:32
std::vector< std::optional< player_iterator > > side_vector
Definition: game.hpp:33
player_connections::const_iterator player_iterator
bmi::multi_index_container< player_record, bmi::indexed_by< bmi::ordered_unique< bmi::tag< socket_t >, bmi::const_mem_fun< player_record, const any_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
std::string_view data
Definition: picture.cpp:199