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