The Battle for Wesnoth  1.17.0-dev
synced_user_choice.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2015 - 2021
3  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 2 of the License, or
8  (at your option) any later version.
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY.
11 
12  See the COPYING file for more details.
13 */
14 
15 
16 #include "synced_user_choice.hpp"
17 
18 #include "actions/undo.hpp"
19 #include "display.hpp"
20 #include "floating_label.hpp"
21 #include "game_data.hpp"
22 #include "log.hpp"
23 #include "play_controller.hpp"
24 #include "synced_context.hpp"
25 #include "replay.hpp"
26 #include "resources.hpp"
28 #include <set>
29 #include <map>
30 #include "formula/string_utils.hpp"
31 #include "font/standard_colors.hpp"
32 
33 static lg::log_domain log_replay("replay");
34 #define DBG_REPLAY LOG_STREAM(debug, log_replay)
35 #define LOG_REPLAY LOG_STREAM(info, log_replay)
36 #define WRN_REPLAY LOG_STREAM(warn, log_replay)
37 #define ERR_REPLAY LOG_STREAM(err, log_replay)
38 
39 namespace
40 {
41  class user_choice_notifer_ingame
42  {
43  //the handle for the label on the screen -1 if not shown yet.
44  int label_id_;
45  std::string message_;
46  unsigned int start_show_;
47 
48  public:
49  user_choice_notifer_ingame()
50  : label_id_(-1)
51  , message_()
52  , start_show_(SDL_GetTicks() + 2000)
53  {
54 
55  }
56 
57  ~user_choice_notifer_ingame()
58  {
59  if(label_id_ != -1) {
60  end_show_label();
61  }
62  }
63 
64  void update(const std::string& message)
65  {
66  if(label_id_ == -1 && SDL_GetTicks() > start_show_)
67  {
68  start_show_label();
69  }
70  if(message == message_) {
71  return;
72  }
73  message_ = message;
74  if(label_id_ != -1) {
75  end_show_label();
76  start_show_label();
77  }
78  }
79 
80  void start_show_label()
81  {
82  assert(label_id_ == -1);
83  SDL_Rect area = display::get_singleton()->map_outside_area();
84  font::floating_label flabel(message_);
87  flabel.set_position(area.w/2, area.h/4);
88  flabel.set_lifetime(-1);
89  flabel.set_clip_rect(area);
90  label_id_ = font::add_floating_label(flabel);
91  }
92 
93  void end_show_label()
94  {
95  assert(label_id_ != -1);
96  font::remove_floating_label(label_id_);
97  label_id_ = -1;
98  }
99  };
100 }
101 
102 std::map<int,config> mp_sync::get_user_choice_multiple_sides(const std::string &name, const mp_sync::user_choice &uch,
103  std::set<int> sides)
104 {
105  //pass sides by copy because we need a copy.
106  const bool is_synced = synced_context::is_synced();
107  const int max_side = static_cast<int>(resources::gameboard->teams().size());
108  //we currently don't check for too early because lua's sync choice doesn't necessarily show screen dialogs.
109  //It (currently) in the responsibility of the user of sync choice to not use dialogs during prestart events..
110  if(!is_synced)
111  {
112  //we got called from inside lua's wesnoth.synchronize_choice or from a select event.
113  replay::process_error("MP synchronization only works in a synced context (for example Select or preload events are no synced context).\n");
114  return std::map<int,config>();
115  }
116 
117  /*
118  for empty sides we want to use random choice instead.
119  */
120  std::set<int> empty_sides;
121  for(int side : sides)
122  {
123  assert(1 <= side && side <= max_side);
124  if( resources::gameboard->get_team(side).is_empty())
125  {
126  empty_sides.insert(side);
127  }
128  }
129 
130  for(int side : empty_sides)
131  {
132  sides.erase(side);
133  }
134 
135  std::map<int,config> retv = user_choice_manager::get_user_choice_internal(name, uch, sides);
136 
137  for(int side : empty_sides)
138  {
139  retv[side] = uch.random_choice(side);
140  }
141  return retv;
142 
143 }
144 
145 /*
146  fixes some rare cases and calls get_user_choice_internal if we are in a synced context.
147 */
148 config mp_sync::get_user_choice(const std::string &name, const mp_sync::user_choice &uch,
149  int side)
150 {
151  const bool is_too_early = resources::gamedata->phase() != game_data::START && resources::gamedata->phase() != game_data::PLAY;
152  const bool is_synced = synced_context::is_synced();
153  const bool is_mp_game = resources::controller->is_networked_mp();//Only used in debugging output below
154  const int max_side = static_cast<int>(resources::gameboard->teams().size());
155  bool is_side_null_controlled;
156 
157  /* side = 0 should default to the currently active side per definition. */
158  if(side < 1 || max_side < side) {
159  if(side != 0) {
160  ERR_REPLAY << "Invalid parameter for side in get_user_choice." << std::endl;
161  }
162 
164  LOG_REPLAY << " side changed to " << side << "\n";
165  }
166 
167  if(!is_synced)
168  {
169  //we got called from inside lua's wesnoth.synchronize_choice or from a select event (or maybe a preload event?).
170  //This doesn't cause problems and someone could use it for example to use a [message][option] inside a wesnoth.synchronize_choice which could be useful,
171  //so just give a warning.
172  LOG_REPLAY << "MP synchronization called during an unsynced context.\n";
173  return uch.query_user(side);
174  }
175  if(is_too_early && uch.is_visible())
176  {
177  //We are in a prestart event or even earlier.
178  //Although we are able to sync them, we cannot use query_user,
179  //because we cannot (or shouldn't) put things on the screen inside a prestart event, this is true for SP and MP games.
180  //Quotation form event wiki: "For things displayed on-screen such as character dialog, use start instead"
181  return uch.random_choice(side);
182  }
183  //in start events it's unclear to decide on which side the function should be executed (default= side1 still).
184  //But for advancements we can just decide on the side that owns the unit and that's in the responsibility of advance_unit_at.
185  //For [message][option] and lua's sync_choice the scenario designer is responsible for that.
186  //For [get_global_variable] side is never null.
187 
188  is_side_null_controlled = resources::gameboard->get_team(side).is_empty();
189 
190  LOG_REPLAY << "get_user_choice_called with"
191  << " name=" << name
192  << " is_synced=" << is_synced
193  << " is_mp_game=" << is_mp_game
194  << " is_side_null_controlled=" << is_side_null_controlled << "\n";
195 
196  if (is_side_null_controlled)
197  {
198  DBG_REPLAY << "MP synchronization: side 1 being null-controlled in get_user_choice.\n";
199  //most likely we are in a start event with an empty side 1
200  //but calling [set_global_variable] to an empty side might also cause this.
201  //i think in that case we should better use uch.random_choice(),
202  //which could return something like config {"invalid", true};
203  side = 1;
204  while ( side <= max_side && resources::gameboard->get_team(side).is_empty() )
205  side++;
206  assert(side <= max_side);
207  }
208 
209 
210  assert(1 <= side && side <= max_side);
211 
212  std::set<int> sides;
213  sides.insert(side);
214  std::map<int, config> retv = user_choice_manager::get_user_choice_internal(name, uch, sides);
215  if(retv.find(side) == retv.end())
216  {
217  //An error occurred, get_user_choice_internal should have given an oos error message
218  return config();
219  }
220  return retv[side];
221 }
222 
223 user_choice_manager::user_choice_manager(const std::string &name, const mp_sync::user_choice &uch, const std::set<int>& sides)
224  : required_(sides)
225  , res_()
226  , local_choice_(0)
227  , wait_message_()
228  , oos_(false)
229  , uch_(uch)
230  , tagname_(name)
231  , current_side_(resources::controller->current_side())
232  , changed_event_("user_choice_update")
233 {
235  const int max_side = static_cast<int>(resources::gameboard->teams().size());
236 
237  for(int side : required_)
238  {
239  assert(1 <= side && side <= max_side);
240  const team& t = resources::gameboard->get_team(side);
241  assert(!t.is_empty());
242  if(side != current_side_)
243  {
245  }
246  }
247 
250 
251 }
252 
254 {
255  while(!finished() && !oos_)
256  {
258  if(resources::recorder->at_end()) {
259  return;
260  }
261 
262  DBG_REPLAY << "MP synchronization: extracting choice from replay with has_local_side=" << has_local_choice() << "\n";
263 
264  const config *action = resources::recorder->get_next_action();
265  assert(action); //action cannot be null because resources::recorder->at_end() returned false.
266  if( !action->has_child(tagname_) || !(*action)["dependent"].to_bool())
267  {
268  replay::process_error("[" + tagname_ + "] expected but none found\n. found instead:\n" + action->debug());
269  //We save this action for later
271  // execute this local choice locally
272  oos_ = true;
274  return;
275  }
276  int from_side = (*action)["from_side"].to_int(0);
277  if((*action)["side_invalid"].to_bool(false) == true)
278  {
279  //since this 'cheat' can have a quite heavy effect especially in umc content we give an oos error .
280  replay::process_error("MP synchronization: side_invalid in replay data, this could mean someone wants to cheat.\n");
281  }
282  if(required_.find(from_side) == required_.end())
283  {
284  replay::process_error("MP synchronization: we got an answer from side " + std::to_string(from_side) + "for [" + tagname_ + "] which is not was we expected\n");
285  }
286  if(res_.find(from_side) != res_.end())
287  {
288  replay::process_error("MP synchronization: we got already our answer from side " + std::to_string(from_side) + "for [" + tagname_ + "] now we have it twice.\n");
289  }
290  res_[from_side] = action->child(tagname_);
292  }
293 }
295 {
296  // there might be speak or similar commands in the replay before the user input.
302 }
303 
305 {
306  int local_choice_prev = local_choice_;
307  //equals to any side in sides that is local, 0 if no such side exists.
308  local_choice_ = 0;
309  //if for any side from which we need an answer
310  std::vector<t_string> sides_str;
311  for(int side : required_)
312  {
313  //and we haven't already received our answer from that side
314  if(res_.find(side) == res_.end())
315  {
316  sides_str.push_back(std::to_string(side));
317  //and it is local
318  if(resources::gameboard->get_team(side).is_local() && !resources::gameboard->get_team(side).is_idle())
319  {
320  //then we have to make a local choice.
321  local_choice_ = side;
322  break;
323  }
324  }
325  }
326 
327  // TRANSLATORS: In networked games, this text is shown on the map while
328  // waiting for $desc from another player.
329  // Don't end the text with a punctuation sign.
331  "waiting for $desc from side $sides",
332  "waiting for $desc from sides $sides",
333  sides_str.size(),
334  {std::pair("desc", uch_.description()), std::pair("sides", utils::format_conjunct_list("", sides_str))}
335  );
336  if(local_choice_prev != local_choice_) {
338  }
339 }
340 
342 {
343  assert(local_choice_ != 0);
344 
346  /* At least one of the decisions is ours, and it will be inserted
347  into the replay. */
348  DBG_REPLAY << "MP synchronization: local choice\n";
350  if(res_.find(local_choice_) != res_.end()) {
351  // It might be possible that we this choice was already made by another client while we were in uch_.query_user
352  // because our side might be reassigned while we made our choice.
353  WRN_REPLAY << "Discarding a local choice because we found it already on the replay";
354  return;
355  }
357  res_[local_choice_] = cfg;
358 
359  //send data to others.
360  //but if there wasn't any data sent during this turn, we don't want to begin with that now.
361  //TODO: we should send user choices during nonundoable actions immediately.
363  {
365  }
367 }
368 
370 {
371  assert(oos_);
372  ERR_REPLAY << "A sync error appeared while waiting for a synced user choice of type '" << uch_.description() << "' ([" + tagname_ + "]), doing the choice locally\n";
373  for(int side : required_)
374  {
375  if(res_.find(side) == res_.end())
376  {
377  ERR_REPLAY << "Doing a local choice for side " << side << "\n";
378  res_[side] = uch_.query_user(side);
379  }
380  }
381  oos_ = false;
382 }
383 
385 {
386  user_choice_notifer_ingame notifer;
387  while(!man.finished() && man.waiting())
388  {
390  {
391  //during the prestart/preload event the screen is locked and we shouldn't call user_interact.
392  //because that might result in crashes if someone clicks anywhere during screenlock.
393 
394  // calls man.pull via events.cpp -> pump_monitor::process
396  }
397 
398  notifer.update(man.wait_message());
399  }
400 }
401 
403 {
404  gui2::dialogs::synched_choice_wait::display(man);
405 }
406 
407 std::map<int, config> user_choice_manager::get_user_choice_internal(const std::string &name, const mp_sync::user_choice &uch, const std::set<int>& sides)
408 {
409  const bool is_too_early = resources::gamedata->phase() != game_data::START && resources::gamedata->phase() != game_data::PLAY;
410  user_choice_manager man(name, uch, sides);
411  while(!man.finished())
412  {
413  if(man.waiting())
414  {
415  if(is_too_early) {
416  wait_prestart(man);
417  }
418  else {
419  wait_ingame(man);
420  }
421  }
422  else if(man.has_local_choice())
423  {
424  man.ask_local_choice();
425  }
426  else
427  {
428  man.fix_oos();
429  }
430  }
431  return man.res_;
432 }
433 
434 namespace {
435  // we want to prevent calling pull() while we are already calling pull()
436  // this could for example happen if pull() receives a [side_drop] and
437  // user_choice_manager::process is called while the "player has left the game.
438  // What do you want to do?" dialog is shown.
439  static bool ucm_in_proccess = false;
440  struct ucm_process_scope {
441  ucm_process_scope() { ucm_in_proccess = true; }
442  ~ucm_process_scope() { ucm_in_proccess = false; }
443  };
444 }
446 {
447  if(!oos_ && !finished() && !ucm_in_proccess)
448  {
449  ucm_process_scope scope1;
450  pull();
451  }
452 }
play_controller * controller
Definition: resources.cpp:22
config get_user_choice(const std::string &name, const user_choice &uch, int side=0)
#define DBG_REPLAY
#define LOG_REPLAY
config & child(config_key_type key, int n=0)
Returns the nth child with the given key, or a reference to an invalid config if there is none...
Definition: config.cpp:402
std::string format_conjunct_list(const t_string &empty, const std::vector< t_string > &elems)
Format a conjunctive list.
bool is_empty() const
Definition: team.hpp:271
static display * get_singleton()
Returns the display object if a display object exists.
Definition: display.hpp:92
static lg::log_domain log_replay("replay")
void remove_floating_label(int handle, int fadeout)
removes the floating label given by &#39;handle&#39; from the screen
virtual const std::vector< team > & teams() const override
Definition: game_board.hpp:85
virtual void notify_observers()
static bool is_simultaneous()
void set_clip_rect(const SDL_Rect &r)
std::set< int > required_
const std::string & tagname_
bool has_child(config_key_type key) const
Determine whether a config has a child or not.
Definition: config.cpp:394
void set_lifetime(int lifetime, int fadeout=100)
static void set_is_simultaneous()
Sets is_simultaneous_ = true, called using a user choice that is not the currently playing side...
static void wait_ingame(user_choice_manager &man)
user_choice_manager(const std::string &name, const mp_sync::user_choice &uch, const std::set< int > &sides)
virtual void play_slice(bool is_delay_enabled=true)
#define VNGETTEXT(msgid, msgid_plural, count,...)
Replay control code.
virtual std::string description() const
void set_font_size(int font_size)
bool waiting() const
Note: currently finished() does not imply !waiting() so you may need to check both.
void process(events::pump_info &)
Inherited from events::pump_monitor.
std::map< int, config > get_user_choice_multiple_sides(const std::string &name, const user_choice &uch, std::set< int > sides)
Performs a choice for multiple sides for WML events.
virtual config random_choice(int side) const =0
game_data * gamedata
Definition: resources.cpp:23
This class stores all the data for a single &#39;side&#39; (in game nomenclature).
Definition: team.hpp:72
team & get_team(int i)
Definition: game_board.hpp:97
void user_input(const std::string &name, const config &input, int from_side)
adds a user_input to the replay
Definition: replay.cpp:255
game_board * gameboard
Definition: resources.cpp:21
Interface for querying local choices.
static std::map< int, config > get_user_choice_internal(const std::string &name, const mp_sync::user_choice &uch, const std::set< int > &sides)
events::generic_event changed_event_
const mp_sync::user_choice & uch_
void set_position(double xpos, double ypos)
map_display and display: classes which take care of displaying the map and game-data on the screen...
replay * recorder
Definition: resources.cpp:29
static void send_user_choice()
called from get_user_choice to send a recently made choice to the other clients.
static void pull_remote_user_input()
called from get_user_choice while waiting for a remove user choice.
virtual config query_user(int side) const =0
static bool is_synced()
const color_t NORMAL_COLOR
void set_color(const color_t &color)
static void process_error(const std::string &msg)
Definition: replay.cpp:196
virtual bool is_networked_mp() const
int current_side_
Definition: move.cpp:315
const SDL_Rect & map_outside_area() const
Returns the available area for a map, this may differ from the above.
Definition: display.hpp:242
int add_floating_label(const floating_label &flabel)
add a label floating on the screen above everything else.
const int SIZE_LARGE
Definition: constants.cpp:30
#define WRN_REPLAY
double t
Definition: astarsearch.cpp:65
Various functions that implement the undoing (and redoing) of in-game commands.
Standard logging facilities (interface).
int current_side() const
Returns the number of the side whose turn it is.
config * get_next_action()
Definition: replay.cpp:620
virtual bool is_visible() const
whether the choice is visible for the user like an advancement choice a non-visible choice is for exa...
void revert_action()
Definition: replay.cpp:613
A RAII object to temporary leave the synced context like in wesnoth.synchronize_choice.
std::map< int, config > res_
PHASE phase() const
Definition: game_data.hpp:79
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:61
REPLAY_RETURN do_replay_handle(bool one_move)
Definition: replay.cpp:702
const std::string & wait_message() const
std::string debug() const
Definition: config.cpp:1347
static void wait_prestart(user_choice_manager &man)
#define ERR_REPLAY