The Battle for Wesnoth 1.21.0-dev
 
Loading...
Searching...
No Matches
mp_staging.cpp
Go to the documentation of this file.
1/*
2 Copyright (C) 2008 - 2025
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#define GETTEXT_DOMAIN "wesnoth-lib"
16
18
19#include "ai/configuration.hpp"
20#include "chat_log.hpp"
23#include "formatter.hpp"
24#include "game_config.hpp"
25#include "gettext.hpp"
31#include "gui/widgets/image.hpp"
32#include "gui/widgets/label.hpp"
39#include "mp_ui_alerts.hpp"
40#include "units/types.hpp"
42
43namespace gui2::dialogs
44{
45
46REGISTER_DIALOG(mp_staging)
47
48mp_staging::mp_staging(ng::connect_engine& connect_engine, wesnothd_connection* connection)
49 : modal_dialog(window_id())
50 , connect_engine_(connect_engine)
51 , ai_algorithms_(ai::configuration::get_available_ais())
52 , network_connection_(connection)
53 , update_timer_(0)
54 , state_changed_(false)
55 , team_tree_map_()
56 , side_tree_map_()
57 , player_list_(nullptr)
58{
59 set_show_even_without_video(true);
60
61 assert(!ai_algorithms_.empty());
62}
63
71
73{
76
77 // Ctrl+G triggers 'I'm Ready' (ok) button's functionality
78 register_hotkey(hotkey::HOTKEY_MP_START_GAME, [this](auto&&...) { start_game(); return true; });
79
81 find_widget<button>("ok").set_tooltip(VGETTEXT("Hotkey(s): $bindings", {{ "bindings", bindings }}));
82
83 //
84 // Set title and status widget states
85 //
86 label& title = find_widget<label>("title");
87 title.set_label((formatter() << connect_engine_.params().name << " " << font::unicode_em_dash << " " << connect_engine_.scenario()["name"].t_str()).str());
88
90
91 //
92 // Set up sides list
93 //
94 for(const auto& side : connect_engine_.side_engines()) {
95 if(side->allow_player() || game_config::debug) {
96 add_side_node(side);;
97 }
98 }
99
100 //
101 // Initialize chatbox and game rooms
102 //
103 chatbox& chat = find_widget<chatbox>("chat");
104
105 chat.room_window_open(N_("this game"), true, false);
107 chat.load_log(default_chat_log, false);
109
110 //
111 // Set up player list
112 //
113 player_list_.reset(new player_list_helper(this));
114
115 //
116 // Set up the network handling
117 //
119
120 //
121 // Set up the Lua plugin context
122 //
123 plugins_context_.reset(new plugins_context("Multiplayer Staging"));
124
125 plugins_context_->set_callback("launch", [this](const config&) { set_retval(retval::OK); }, false);
126 plugins_context_->set_callback("quit", [this](const config&) { set_retval(retval::CANCEL); }, false);
127 plugins_context_->set_callback("chat", [&chat](const config& cfg) { chat.send_chat_message(cfg["message"], false); }, true);
128}
129
131{
132 int position = 0;
133 for(const auto& side_engine : connect_engine_.side_engines()) {
134 if(side->team() == side_engine->team() && side->index() > side_engine->index()) {
135 ++position;
136 }
137 }
138
139 return position;
140}
141
142template<typename... T>
144{
145 static const widget_data empty_map;
146
147 // If there is no team node in the map, this will return nullptr
148 tree_view_node* team_node = team_tree_map_[side->team_name()];
149
150 // Add a team node if none exists
151 if(team_node == nullptr) {
152 tree_view& tree = find_widget<tree_view>("side_list");
153
154 widget_data tree_data;
155 widget_item tree_item;
156
157 tree_item["label"] = side->user_team_name();
158 tree_data.emplace("tree_view_node_label", tree_item);
159
160 team_node = &tree.add_node("team_header", tree_data);
161 team_node->add_sibling("side_spacer", empty_map);
162
163 team_tree_map_[side->team_name()] = team_node;
164 }
165
166 assert(team_node && "No team node found!");
167 return team_node->add_child(std::forward<T>(params)...);
168}
169
171{
173 widget_item item;
174
175 item["label"] = std::to_string(side->index() + 1);
176 data.emplace("side_number", item);
177
178 // TODO: don't hardcode magenta?
179 item["label"] = "units/unknown-unit.png~RC(magenta>" + side->color_id() + ")";
180 data.emplace("leader_image", item);
181
182 item["label"] = "icons/icon-random.png";
183 data.emplace("leader_gender", item);
184
185 tree_view_node& node = add_side_to_team_node(side, "side_panel", data, get_side_node_position(side));
186
187 side_tree_map_[side] = &node;
188
189 grid& row_grid = node.get_grid();
190
191 update_leader_display(side, row_grid);
192
193 // Status variables
194 const bool fls = connect_engine_.force_lock_settings();
195 const bool ums = connect_engine_.params().use_map_settings;
196
197 const bool lock_gold = side->cfg()["gold_lock"].to_bool(fls);
198 const bool lock_income = side->cfg()["income_lock"].to_bool(fls);
199 const bool lock_team = side->cfg()["team_lock"].to_bool(fls);
200 const bool lock_color = side->cfg()["color_lock"].to_bool(fls);
201
202 const bool saved_game = connect_engine_.params().saved_game == saved_game_mode::type::midgame;
203
204 //
205 // AI Algorithm
206 //
207 int selection = 0;
208
209 // We use an index-based loop in order to get the index of the selected option
210 std::vector<config> ai_options;
211 // If this is loading a saved game, we add an option at the beginning of the menu.
212 // This results in a mismatch between the indices of ai_options and ai_algorithms_
213 // that we need to account for later.
214 if(saved_game) {
215 ai_options.emplace_back("label", "Keep saved AI");
216 }
217 for(unsigned i = 0; i < ai_algorithms_.size(); ++i) {
218 ai_options.emplace_back("label", ai_algorithms_[i]->text);
219
220 if(ai_algorithms_[i]->id == side->ai_algorithm()) {
221 selection = i;
222 }
223 }
224
225 menu_button& ai_selection = row_grid.find_widget<menu_button>("ai_controller");
226
227 ai_selection.set_values(ai_options, selection);
228
229 connect_signal_notify_modified(ai_selection,
230 std::bind(&mp_staging::on_ai_select, this, side, std::ref(ai_selection), saved_game));
231
232 on_ai_select(side, ai_selection, saved_game);
233 //
234 // Controller
235 //
236 std::vector<config> controller_names;
237 for(const auto& controller : side->controller_options()) {
238 controller_names.emplace_back("label", controller.second);
239 }
240
241 menu_button& controller_selection = row_grid.find_widget<menu_button>("controller");
242
243 controller_selection.set_values(controller_names, side->current_controller_index());
244 controller_selection.set_active(controller_names.size() > 1);
245
246 connect_signal_notify_modified(controller_selection,
247 std::bind(&mp_staging::on_controller_select, this, side, std::ref(row_grid)));
248
249 on_controller_select(side, row_grid);
250
251 //
252 // Leader controls
253 //
254 button& leader_select = row_grid.find_widget<button>("select_leader");
255
256 //todo: shouldn't this also be disabled when the flg settings are locked.
257 leader_select.set_active(!saved_game);
258
259 connect_signal_mouse_left_click(leader_select,
260 std::bind(&mp_staging::select_leader_callback, this, side, std::ref(row_grid)));
261
262 //
263 // Team
264 //
265 std::vector<config> team_names;
266 unsigned initial_team_selection = 0;
267
268 for(unsigned i = 0; i < connect_engine_.team_data().size(); ++i) {
270
271 if(!tdata.is_player_team && !game_config::debug) {
272 continue;
273 }
274
275 config entry;
276 entry["label"] = t_string::from_serialized(tdata.user_team_name);
277
278 // Since we're not necessarily displaying every every team, we need to store the
279 // index a displayed team has in the connect_engine's team_data vector. This is
280 // then utilized in the click callback.
281 entry["team_index"] = i;
282
283 team_names.push_back(std::move(entry));
284
285 // Since, again, every team might not be displayed, and side_engine::team() returns
286 // an index into the team_data vector, get an initial selection index for the menu
287 // adjusted for the displayed named.
288 if(side->team() == i) {
289 initial_team_selection = team_names.size() - 1;
290 }
291 }
292
293 menu_button& team_selection = row_grid.find_widget<menu_button>("side_team");
294
295 team_selection.set_values(team_names, initial_team_selection);
296 //todo: shouldn't this also be disabled when team settings are locked.
297 team_selection.set_active(!saved_game);
298
299 connect_signal_notify_modified(team_selection,
300 std::bind(&mp_staging::on_team_select, this, side, std::ref(team_selection)));
301
302 //
303 // Colors
304 //
305 std::vector<config> color_options;
306 for(const auto& color_opt : side->color_options()) {
307 auto name = game_config::team_rgb_name.find(color_opt);
308 auto color = game_config::team_rgb_range.find(color_opt);
309 auto team_color = _("Invalid Color");
310
312 team_color = markup::span_color(color->second.font_color(), name->second);
313 }
314
315 // The name will be in the font_color shade, but the icon will be in the mid() shade, like a recolored unit
316 color_options.emplace_back(
317 "label", team_color,
318 "icon", (formatter() << "misc/status.png~RC(magenta>" << color_opt << ")").str()
319 );
320 }
321
322 menu_button& color_selection = row_grid.find_widget<menu_button>("side_color");
323
324 color_selection.set_values(color_options, side->color());
325 color_selection.set_active(!saved_game);
326 color_selection.set_use_markup(true);
327
328 connect_signal_notify_modified(color_selection,
329 std::bind(&mp_staging::on_color_select, this, side, std::ref(row_grid)));
330
331 //
332 // Gold and Income
333 //
334 const auto slider_setup_helper = [](slider& slider, const int value) {
335 // For the gold and income sliders, the usual min and max values are set in
336 // the dialog WML. However, if a side specifies a value out of that range,
337 // we adjust the bounds to accommodate it.
339 std::min(value, slider.get_minimum_value()),
340 std::max(value, slider.get_maximum_value())
341 );
342
344 };
345
346 slider& slider_gold = row_grid.find_widget<slider>("side_gold_slider");
347 slider_setup_helper(slider_gold, side->gold());
348
349 connect_signal_notify_modified(slider_gold, std::bind(
350 &mp_staging::on_side_slider_change<&ng::side_engine::set_gold>, this, side, std::ref(slider_gold)));
351
352 slider& slider_income = row_grid.find_widget<slider>("side_income_slider");
353 slider_setup_helper(slider_income, side->income());
354
355 connect_signal_notify_modified(slider_income, std::bind(
356 &mp_staging::on_side_slider_change<&ng::side_engine::set_income>, this, side, std::ref(slider_income)));
357
358 // TODO: maybe display the saved values
359 if(saved_game) {
362 }
363
364 //
365 // Gold, income, team, and color are only suggestions unless explicitly locked
366 //
367 if(!saved_game && ums) {
368 team_selection.set_active(!lock_team);
369 color_selection.set_active(!lock_color);
370
371 slider_gold.set_active(!lock_gold);
372 slider_income.set_active(!lock_income);
373 }
374}
375
377{
378 menu_button& ai_selection = row_grid.find_widget<menu_button>("ai_controller");
379 menu_button& controller_selection = row_grid.find_widget<menu_button>("controller");
380
381 if(side->controller_changed(controller_selection.get_value())) {
383
385 }
386}
387
389{
390 // If this is a saved game, we need to reduce the index by one, to account for
391 // the "Keep saved AI" option having been added to the computer player menu
392 int i = ai_menu.get_value();
393 if(saved_game) {
394 i--;
395 }
396
397 if(i < 0) {
398 side->set_ai_algorithm("use_saved");
399 } else {
400 side->set_ai_algorithm(ai_algorithms_[i]->id);
401 }
402
404}
405
407{
408 side->set_color(row_grid.find_widget<menu_button>("side_color").get_value());
409
410 update_leader_display(side, row_grid);
411
413}
414
416{
417 // Since we're not necessarily displaying every every team in the menu, we can't just
418 // use the selected index to set a side's team. Instead, we grab the index we stored
419 // in add_side_node from the selected config, which should correspond to the
420 // appropriate entry in the connect_engine's team name vector.
421 const unsigned team_index = team_menu.get_value_config()["team_index"].to_unsigned();
422
423 if(team_index == side->team()) {
424 return;
425 }
426
427 // Note the old team so we can remove the node if empty after the side move.
428 // Do this *before* setting the new team!
429 const std::string old_team = side->team_name();
430 side->set_team(team_index);
431
432 auto& tree = find_widget<tree_view>("side_list");
433
434 // First, remove the node from the tree
435 auto node = tree.remove_node(side_tree_map_[side]);
436
437 // Then add a new node as a child to the appropriate team's node
438 add_side_to_team_node(side, std::move(node.first), get_side_node_position(side));
439
440 tree_view_node* old_team_node = team_tree_map_[old_team];
441
442 // Last, remove the old team node if it's now empty
443 if(old_team_node->empty()) {
444 // Decor node will be immediately after team node. Remove this first!
445 tree.remove_node(old_team_node->get_node_below());
446 tree.remove_node(old_team_node);
447
448 team_tree_map_[old_team] = nullptr;
449 }
450
452}
453
455{
456 if(gui2::dialogs::faction_select::execute(side->flg(), side->color_id(), side->index() + 1)) {
457 update_leader_display(side, row_grid);
458
460 }
461}
462
463template<void(ng::side_engine::*fptr)(int)>
465{
466 std::invoke(fptr, side, slider.get_value());
467
469}
470
472{
473 // BIG FAT TODO: get rid of this shitty "null" string value in the FLG manager
474 std::string current_leader = side->flg().current_leader() != "null" ? side->flg().current_leader() : font::unicode_em_dash;
475 const std::string current_gender = side->flg().current_gender() != "null" ? side->flg().current_gender() : font::unicode_em_dash;
476
477 // Sprite
478 std::string new_image;
479
480 if(side->flg().is_random_faction() || current_leader == "random") {
481 new_image = ng::random_enemy_picture;
482 }
483
484 if(const unit_type* ut = unit_types.find(current_leader)) {
485 const unit_type& type = ut->get_gender_unit_type(current_gender);
486
487 new_image = formatter() << type.image() << "~RC(magenta>" << side->color_id() << ")";
488
489 // We don't need the unit type id anymore, and can now replace this variable with the type name
490 current_leader = type.type_name();
491 }
492
493 row_grid.find_widget<drawing>("leader_image").set_label(new_image);
494
495 // Faction and leader
496 if(!side->cfg()["name"].empty()) {
497 current_leader = formatter() << side->cfg()["name"] << " (" << markup::italic(current_leader) << ")";
498 }
499
500 row_grid.find_widget<label>("leader_type").set_label(current_leader == "random" ? _("Random") : current_leader);
501 row_grid.find_widget<label>("leader_faction").set_label(side->flg().current_faction()["name"].t_str());
502
503 // Gender
504 if(current_gender != font::unicode_em_dash) {
505 const std::string gender_icon = formatter() << "icons/icon-" << current_gender << ".png";
506
507 image& icon = row_grid.find_widget<image>("leader_gender");
508 icon.set_label(gender_icon);
509 }
510}
511
513{
514 find_widget<label>("status_label").set_label(
516 ? _("Waiting for players to join...")
517 : _("Waiting for players to choose factions...")
518 );
519
520 find_widget<button>("ok").set_active(connect_engine_.can_start_game());
521}
522
524{
525 // First, send off any changes if they've been accumulated
526 if(state_changed_) {
528 }
529
530 // Next, check for any incoming changes
531 config data;
533 return;
534 }
535
536 // Update chat
537 chatbox& chat = find_widget<chatbox>("chat");
539
540 // TODO: why is this needed...
541 const bool was_able_to_start = connect_engine_.can_start_game();
542 const bool quit_signal_received = connect_engine_.process_network_data(data);
543
544 // Keep the chat's auto-completion roster synchronised with who is actually connected,
545 // since this screen no longer receives the main lobby's user list updates.
547
548 if(quit_signal_received) {
550 }
551
552 // Update side leader displays
553 // This is basically only needed when a new player joins and selects their faction
554 for(auto& tree_entry : side_tree_map_) {
555 ng::side_engine_ptr side = tree_entry.first;
556
557 grid& row_grid = tree_entry.second->get_grid();
558
559 update_leader_display(side, row_grid);
560
561 std::vector<config> controller_names;
562 for(const auto& controller : side->controller_options()) {
563 controller_names.emplace_back("label", controller.second);
564 }
565
566 menu_button& controller_selection = row_grid.find_widget<menu_button>("controller");
567
568 controller_selection.set_values(controller_names, side->current_controller_index());
569 controller_selection.set_active(controller_names.size() > 1);
570 }
571
572 // Update player list
573 if(data.has_child("user")) {
574 player_list_->update_list(data.child_range("user"));
575 }
576
577 // Update status label and buttons
579
580 if(!was_able_to_start && connect_engine_.can_start_game()) {
582 }
583
584 state_changed_ = false;
585}
586
588{
589 if(update_timer_ != 0) {
591 update_timer_ = 0;
592 }
593
594 if(get_retval() == retval::OK) {
596 } else {
598 }
599}
600
601} // namespace dialogs
std::map< std::string, chatroom_log > default_chat_log
Definition chat_log.cpp:18
A config object defines a single node in a WML file, with access to child nodes.
Definition config.hpp:157
std::ostringstream wrapper.
Definition formatter.hpp:40
Simple push button.
Definition button.hpp:36
virtual void set_active(const bool active) override
See styled_widget::set_active.
Definition button.cpp:64
lobby_chat_window * room_window_open(const std::string &room, const bool open_new, const bool allow_close=true)
Check if a room window for "room" is open, if open_new is true then it will be created if not found.
Definition chatbox.cpp:379
void set_available_users(const std::set< std::string > &names)
Supplies an additional set of names to offer for auto-completion, on top of whatever mp::get_lobby_in...
Definition chatbox.hpp:99
virtual void send_chat_message(const std::string &message, bool allies_only) override
Inherited form chat_handler.
Definition chatbox.cpp:253
void process_network_data(const ::config &data)
Definition chatbox.cpp:625
void load_log(std::map< std::string, chatroom_log > &log, bool show_lobby)
Definition chatbox.cpp:90
void active_window_changed()
Definition chatbox.cpp:115
Abstract base class for all modal dialogs.
void update_leader_display(const ng::side_engine_ptr &side, grid &row_grid)
tree_view_node & add_side_to_team_node(const ng::side_engine_ptr &side, T &&... params)
wesnothd_connection * network_connection_
void on_color_select(const ng::side_engine_ptr &side, grid &row_grid)
virtual void post_show() override
Actions to be taken after the window has been shown.
void select_leader_callback(const ng::side_engine_ptr &side, grid &row_grid)
void on_ai_select(const ng::side_engine_ptr &side, menu_button &ai_menu, const bool saved_game)
ng::connect_engine & connect_engine_
int get_side_node_position(const ng::side_engine_ptr &side) const
Find an appropriate position to insert a side node.
void add_side_node(const ng::side_engine_ptr &side)
void on_team_select(const ng::side_engine_ptr &side, menu_button &team_menu)
std::map< ng::side_engine_ptr, tree_view_node * > side_tree_map_
std::unique_ptr< player_list_helper > player_list_
std::vector< ai::description * > ai_algorithms_
std::map< std::string, tree_view_node * > team_tree_map_
virtual void pre_show() override
Actions to be taken before showing the window.
void on_side_slider_change(const ng::side_engine_ptr &side, slider &slider)
void on_controller_select(const ng::side_engine_ptr &side, grid &row_grid)
std::unique_ptr< plugins_context > plugins_context_
void register_hotkey(const hotkey::HOTKEY_COMMAND id, Func &&function)
Registers a hotkey.
Base container class.
Definition grid.hpp:32
void set_values(const std::vector<::config > &values, unsigned selected=0)
virtual unsigned get_value() const override
Inherited from selectable_item.
const ::config & get_value_config() const
Returns the entire config object for the selected row.
virtual void set_active(const bool active) override
See styled_widget::set_active.
virtual void set_active(const bool active) override
See styled_widget::set_active.
virtual int get_minimum_value() const override
Inherited from integer_selector.
Definition slider.hpp:58
virtual void set_value(int value) override
Inherited from integer_selector.
Definition slider.cpp:81
virtual int get_maximum_value() const override
Inherited from integer_selector.
Definition slider.hpp:64
void set_value_range(int min_value, int max_value)
Definition slider.cpp:249
virtual int get_value() const override
Inherited from integer_selector.
Definition slider.hpp:52
virtual void set_label(const t_string &text)
virtual void set_use_markup(bool use_markup)
bool empty() const
Does the node have children?
tree_view_node & add_sibling(const std::string &id, const widget_data &data)
Adds a sibling for a node at the end of the list.
tree_view_node & add_child(const std::string &id, const widget_data &data, const int index=-1)
Constructs a new child node.
tree_view_node * get_node_below()
tree_view_node & add_node(const std::string &id, const widget_data &data, const int index=-1)
Definition tree_view.cpp:57
T * find_widget(const std::string_view id, const bool must_be_active, const bool must_exist)
Gets a widget with the wanted id.
Definition widget.hpp:747
void set_visible(const visibility visible)
Definition widget.cpp:479
@ visible
The user sets the widget visible, that means:
@ invisible
The user set the widget invisible, that means:
@ hidden
The user sets the widget hidden, that means:
void set_enter_disabled(const bool enter_disabled)
Disable the enter key.
Definition window.hpp:313
void set_retval(const int retval, const bool close_window=true)
Sets there return value of the window.
Definition window.hpp:387
static const std::string & type()
Static type getter that does not rely on the widget being constructed.
void set_escape_disabled(const bool escape_disabled)
Disable the escape key.
Definition window.hpp:326
int get_retval()
Definition window.hpp:394
const mp_game_settings & params() const
bool sides_available() const
bool force_lock_settings() const
const std::set< std::string > & connected_users() const
const std::vector< side_engine_ptr > & side_engines() const
const std::vector< team_data_pod > & team_data() const
bool process_network_data(const config &data)
bool can_start_game() const
static t_string from_serialized(const std::string &string)
Definition tstring.hpp:165
const unit_type * find(const std::string &key, unit_type::BUILD_STATUS status=unit_type::FULL) const
Finds a unit_type by its id() and makes sure it is built to the specified level.
Definition types.cpp:1253
A single unit type that the player may recruit.
Definition types.hpp:43
const unit_type & get_gender_unit_type(const std::string &gender) const
Returns a gendered variant of this unit_type.
Definition types.cpp:416
A class that represents a TCP/IP connection to the wesnothd server.
bool receive_data(config &result)
Receives the next pending data pack from the server, if available.
Managing the AIs configuration - headers.
const config * cfg
#define VGETTEXT(msgid,...)
Handy wrappers around interpolate_variables_into_string and gettext.
#define N_(String)
Definition gettext.hpp:108
static std::string _(const char *str)
Definition gettext.hpp:100
#define REGISTER_DIALOG(window_id)
Wrapper for REGISTER_DIALOG2.
A small explanation about what's going on here: Each action has access to two game_info objects First...
Definition actions.cpp:59
const std::string unicode_em_dash
Definition constants.cpp:44
std::map< std::string, color_range, std::less<> > team_rgb_range
Colors defined by WML [color_range] tags.
std::map< std::string, t_string, std::less<> > team_rgb_name
const bool & debug
std::chrono::milliseconds lobby_network_timer
std::size_t add_timer(const std::chrono::milliseconds &interval, const std::function< void(std::size_t id)> &callback, const bool repeat)
Adds a new timer.
Definition timer.cpp:123
std::map< std::string, widget_item > widget_data
Definition widget.hpp:36
std::map< std::string, t_string > widget_item
Definition widget.hpp:33
bool remove_timer(const std::size_t id)
Removes a timer.
Definition timer.cpp:164
@ OK
Dialog was closed with the OK button.
Definition retval.hpp:35
@ CANCEL
Dialog was closed with the CANCEL button.
Definition retval.hpp:38
std::string get_names(const std::string &id)
Returns a comma-separated string of hotkey names.
const hotkey_command & get_hotkey_command(std::string_view command)
Returns the hotkey_command with the given id.
Functions to load and save images from/to disk.
std::string italic(Args &&... data)
Applies italic Pango markup to the input.
Definition markup.hpp:176
std::string span_color(const color_t &color, Args &&... data)
Applies Pango markup to the input specifying its display color.
Definition markup.hpp:110
@ CNTR_COMPUTER
std::shared_ptr< side_engine > side_engine_ptr
const std::string random_enemy_picture("units/random-dice.png")
std::string_view data
Definition picture.cpp:188
std::unique_ptr< MIX_Audio, decltype(&MIX_DestroyAudio)> value
Definition sound.cpp:139
saved_game_mode::type saved_game
unit_type_data unit_types
Definition types.cpp:1499
#define i