The Battle for Wesnoth  1.19.0-dev
game_config.cpp
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 #include "game_config.hpp"
17 
18 #include "color_range.hpp"
19 #include "config.hpp"
20 #include "gettext.hpp"
21 #include "log.hpp"
22 #include "utils/math.hpp"
23 #include "game_version.hpp"
24 #include "wesconfig.h"
26 
27 static lg::log_domain log_engine("engine");
28 #define LOG_NG LOG_STREAM(info, log_engine)
29 #define ERR_NG LOG_STREAM(err, log_engine)
30 
31 namespace game_config
32 {
33 //
34 // Gameplay constants
35 //
36 int base_income = 2;
39 int recall_cost = 20;
42 
43 int poison_amount = 8;
45 
47 
48 //
49 // Terrain-related constants
50 //
51 unsigned int tile_size = 72;
52 
53 std::string default_terrain;
55 
56 std::vector<unsigned int> zoom_levels {36, 72, 144};
57 
58 //
59 // Display scale constants
60 //
61 double hp_bar_scaling = 0.666;
62 double xp_bar_scaling = 0.5;
63 
64 //
65 // Misc
66 //
67 unsigned lobby_network_timer = 100;
68 unsigned lobby_refresh = 4000;
69 
70 const std::size_t max_loop = 65536;
71 
72 std::vector<server_info> server_list;
73 
74 bool allow_insecure = false;
75 
76 //
77 // Gamestate flags
78 //
79 bool
80  debug_impl = false,
81  debug_lua = false,
82  strict_lua = false,
83  editor = false,
85  mp_debug = false,
86  exit_at_end = false,
87  no_delay = false,
89  no_addons = false;
90 
91 const bool& debug = debug_impl;
92 
93 void set_debug(bool new_debug) {
94  // TODO: remove severity static casts and fix issue #7894
95  if(debug_impl && !new_debug) {
96  // Turning debug mode off; decrease deprecation severity
98  if(lg::get_log_domain_severity("deprecation", severity)) {
99  int severityInt = static_cast<int>(severity);
100  lg::set_log_domain_severity("deprecation", static_cast<lg::severity>(severityInt - 2));
101  }
102  } else if(!debug_impl && new_debug) {
103  // Turning debug mode on; increase deprecation severity
105  if(lg::get_log_domain_severity("deprecation", severity)) {
106  int severityInt = static_cast<int>(severity);
107  lg::set_log_domain_severity("deprecation", static_cast<lg::severity>(severityInt + 2));
108  }
109  }
110  debug_impl = new_debug;
111 }
112 
113 //
114 // Orb display flags
115 //
123 
124 //
125 // Music constants
126 //
128 
129 std::vector<std::string> default_defeat_music;
130 std::vector<std::string> default_victory_music;
131 
132 //
133 // Color info
134 //
135 std::string flag_rgb, unit_rgb;
136 
137 std::vector<color_t> red_green_scale;
138 std::vector<color_t> red_green_scale_text;
139 
140 static std::vector<color_t> blue_white_scale;
141 static std::vector<color_t> blue_white_scale_text;
142 
143 std::map<std::string, color_range, std::less<>> team_rgb_range;
144 // Map [color_range]id to [color_range]name, or "" if no name
145 std::map<std::string, t_string, std::less<>> team_rgb_name;
146 
147 std::map<std::string, std::vector<color_t>, std::less<>> team_rgb_colors;
148 
149 std::vector<std::string> default_colors;
150 
151 namespace colors
152 {
153 std::string ally_orb_color;
154 std::string enemy_orb_color;
155 std::string moved_orb_color;
156 std::string partial_orb_color;
157 std::string unmoved_orb_color;
158 std::string default_color_list;
159 } // namespace colors
160 
161 //
162 // Image constants
163 //
164 std::vector<std::string> foot_speed_prefix;
165 
167 std::string foot_teleport_exit;
168 
169 namespace images {
170 
171 std::string
179  // orbs and hp/xp bar
183  // top bar icons
186  // flags
189  // hex overlay
198  // GUI elements
202  // TODO: de-hardcode this
203  selected_menu = "buttons/radiobox-pressed.png",
204  deselected_menu = "buttons/radiobox.png",
205  checked_menu = "buttons/checkbox-pressed.png",
206  unchecked_menu = "buttons/checkbox.png",
207  wml_menu = "buttons/WML-custom.png",
212  // notifications icon
213  app_icon = "images/icons/icon-game.png";
214 
215 } //images
216 
217 //
218 // Sound constants
219 //
220 namespace sounds {
221 
222 std::string
223  turn_bell = "bell.wav",
224  timer_bell = "timer.wav",
225  public_message = "chat-[1~3].ogg",
226  private_message = "chat-highlight.ogg",
227  friend_message = "chat-friend.ogg",
228  server_message = "receive.wav",
229  player_joins = "arrive.wav",
230  player_leaves = "leave.wav",
231  game_user_arrive = "join.wav",
232  game_user_leave = "leave.wav",
233  ready_for_start = "bell.wav",
234  game_has_begun = "gamestart.ogg",
235  game_created = "join.wav";
236 
237 const std::string
238  button_press = "button.wav",
239  checkbox_release = "checkbox.wav",
240  slider_adjust = "slider.wav",
241  menu_expand = "expand.wav",
242  menu_contract = "contract.wav",
243  menu_select = "select.wav";
244 
245 namespace status {
246 
247 std::string
248  poisoned = "poison.ogg",
249  slowed = "slowed.wav",
250  petrified = "petrified.ogg";
251 
252 } // status
253 
254 } // sounds
255 
256 static void add_color_info(const game_config_view& v, bool build_defaults);
258 {
259  add_color_info(v, false);
260 }
261 
262 void load_config(const config &v)
263 {
264  base_income = v["base_income"].to_int(2);
265  village_income = v["village_income"].to_int(1);
266  village_support = v["village_support"].to_int(1);
267  poison_amount = v["poison_amount"].to_int(8);
268  rest_heal_amount = v["rest_heal_amount"].to_int(2);
269  recall_cost = v["recall_cost"].to_int(20);
270  kill_experience = v["kill_experience"].to_int(8);
271  combat_experience= v["combat_experience"].to_int(1);
272  lobby_refresh = v["lobby_refresh"].to_int(2000);
273  default_terrain = v["default_terrain"].str();
274  tile_size = v["tile_size"].to_int(72);
275 
276  std::vector<std::string> zoom_levels_str = utils::split(v["zoom_levels"]);
277  if(!zoom_levels_str.empty()) {
278  zoom_levels.clear();
279  std::transform(zoom_levels_str.begin(), zoom_levels_str.end(), std::back_inserter(zoom_levels), [](const std::string zoom) {
280  int z = std::stoi(zoom);
281  if((z / 4) * 4 != z) {
282  ERR_NG << "zoom level " << z << " is not divisible by 4."
283  << " This will cause graphical glitches!";
284  }
285  return z;
286  });
287  }
288 
289  title_music = v["title_music"].str();
290  lobby_music = v["lobby_music"].str();
291 
292  default_victory_music = utils::split(v["default_victory_music"].str());
293  default_defeat_music = utils::split(v["default_defeat_music"].str());
294 
295  if(auto i = v.optional_child("colors")){
296  using namespace game_config::colors;
297 
298  moved_orb_color = i["moved_orb_color"].str();
299  unmoved_orb_color = i["unmoved_orb_color"].str();
300  partial_orb_color = i["partial_orb_color"].str();
301  enemy_orb_color = i["enemy_orb_color"].str();
302  ally_orb_color = i["ally_orb_color"].str();
303  } // colors
304 
305  show_ally_orb = v["show_ally_orb"].to_bool(true);
306  show_enemy_orb = v["show_enemy_orb"].to_bool(false);
307  show_moved_orb = v["show_moved_orb"].to_bool(true);
308  show_partial_orb = v["show_partial_orb"].to_bool(true);
309  show_status_on_ally_orb = v["show_status_on_ally_orb"].to_bool(true);
310  show_unmoved_orb = v["show_unmoved_orb"].to_bool(true);
311  show_disengaged_orb = v["show_disengaged_orb"].to_bool(true);
312 
313  if(auto i = v.optional_child("images")){
314  using namespace game_config::images;
315 
316  game_title = i["game_title"].str();
317  game_title_background = i["game_title_background"].str();
318  game_logo = i["game_logo"].str();
319  game_logo_background = i["game_logo_background"].str();
320 
321  victory_laurel = i["victory_laurel"].str();
322  victory_laurel_hardest = i["victory_laurel_hardest"].str();
323  victory_laurel_easy = i["victory_laurel_easy"].str();
324 
325  orb = i["orb"].str();
326  orb_two_color = i["orb_two_color"].str();
327  energy = i["energy"].str();
328 
329  battery_icon = i["battery_icon"].str();
330  time_icon = i["time_icon"].str();
331 
332  flag = i["flag"].str();
333  flag_icon = i["flag_icon"].str();
334 
335  terrain_mask = i["terrain_mask"].str();
336  grid_top = i["grid_top"].str();
337  grid_bottom = i["grid_bottom"].str();
338  mouseover = i["mouseover"].str();
339  selected = i["selected"].str();
340  editor_brush = i["editor_brush"].str();
341  unreachable = i["unreachable"].str();
342  linger = i["linger"].str();
343 
344  observer = i["observer"].str();
345  tod_bright = i["tod_bright"].str();
346  tod_dark = i["tod_dark"].str();
347  level = i["level"].str();
348  ellipsis = i["ellipsis"].str();
349  missing = i["missing"].str();
350  blank = i["blank"].str();
351  } // images
352 
353  hp_bar_scaling = v["hp_bar_scaling"].to_double(0.666);
354  xp_bar_scaling = v["xp_bar_scaling"].to_double(0.5);
355 
356  foot_speed_prefix = utils::split(v["footprint_prefix"]);
357  foot_teleport_enter = v["footprint_teleport_enter"].str();
358  foot_teleport_exit = v["footprint_teleport_exit"].str();
359 
360  shroud_prefix = v["shroud_prefix"].str();
361  fog_prefix = v["fog_prefix"].str();
362 
364 
365  if(const config::attribute_value* a = v.get("flag_rgb")) {
366  flag_rgb = a->str();
367  }
368 
369  if(const config::attribute_value* a = v.get("unit_rgb")) {
370  unit_rgb = a->str();
371  }
372 
373  const auto parse_config_color_list = [&](
374  const std::string& key,
375  const color_t fallback)->std::vector<color_t>
376  {
377  std::vector<color_t> color_vec;
378 
379  for(const auto& s : utils::split(v[key].str())) {
380  try {
381  color_vec.push_back(color_t::from_hex_string(s));
382  } catch(const std::invalid_argument& e) {
383  ERR_NG << "Error parsing color list '" << key << "'.\n" << e.what();
384  color_vec.push_back(fallback);
385  }
386  }
387 
388  return color_vec;
389  };
390 
391  red_green_scale = parse_config_color_list("red_green_scale", {255, 255, 255});
392  red_green_scale_text = parse_config_color_list("red_green_scale_text", {255, 255, 255});
393  blue_white_scale = parse_config_color_list("blue_white_scale", {0 , 0 , 255});
394  blue_white_scale_text = parse_config_color_list("blue_white_scale_text", {0 , 0 , 255});
395 
396  server_list.clear();
397 
398  for(const config& server : v.child_range("server")) {
399  server_info sinf;
400  sinf.name = server["name"].str();
401  sinf.address = server["address"].str();
402  server_list.push_back(sinf);
403  }
404 
405  if(auto s = v.optional_child("sounds")) {
406  using namespace game_config::sounds;
407 
408  const auto load_attribute = [](const config& c, const std::string& key, std::string& member) {
409  if(c.has_attribute(key)) {
410  member = c[key].str();
411  }
412  };
413 
414  load_attribute(*s, "turn_bell", turn_bell);
415  load_attribute(*s, "timer_bell", timer_bell);
416  load_attribute(*s, "public_message", public_message);
417  load_attribute(*s, "private_message", private_message);
418  load_attribute(*s, "friend_message", friend_message);
419  load_attribute(*s, "server_message", server_message);
420  load_attribute(*s, "player_joins", player_joins);
421  load_attribute(*s, "player_leaves", player_leaves);
422  load_attribute(*s, "game_created", game_created);
423  load_attribute(*s, "game_user_arrive", game_user_arrive);
424  load_attribute(*s, "game_user_leave", game_user_leave);
425  load_attribute(*s, "ready_for_start", ready_for_start);
426  load_attribute(*s, "game_has_begun", game_has_begun);
427 
428  if(auto ss = s->optional_child("status")) {
429  using namespace game_config::sounds::status;
430 
431  load_attribute(*ss, "poisoned", poisoned);
432  load_attribute(*ss, "slowed", slowed);
433  load_attribute(*ss, "petrified", petrified);
434  }
435  }
436 }
437 
438 void add_color_info(const game_config_view& v, bool build_defaults)
439 {
440  if(build_defaults) {
441  default_colors.clear();
442  }
443 
444  for(const config& teamC : v.child_range("color_range")) {
445  const config::attribute_value* a1 = teamC.get("id"), *a2 = teamC.get("rgb");
446  if(!a1 || !a2) {
447  continue;
448  }
449 
450  std::string id = *a1;
451  std::vector<color_t> temp;
452 
453  for(const auto& s : utils::split(*a2)) {
454  try {
455  temp.push_back(color_t::from_hex_string(s));
456  } catch(const std::invalid_argument&) {
457  std::stringstream ss;
458  ss << "can't parse color string:\n" << teamC.debug() << "\n";
459  throw config::error(ss.str());
460  }
461  }
462 
463  team_rgb_range.emplace(id, color_range(temp));
464  team_rgb_name.emplace(id, teamC["name"].t_str());
465 
466  LOG_NG << "registered color range '" << id << "': " << team_rgb_range[id].debug();
467 
468  // Ggenerate palette of same name;
469  std::vector<color_t> tp = palette(team_rgb_range[id]);
470  if(!tp.empty()) {
471  team_rgb_colors.emplace(id, tp);
472  }
473 
474  if(build_defaults && teamC["default"].to_bool()) {
475  default_colors.push_back(*a1);
476  }
477  }
478 
479  for(const config &cp : v.child_range("color_palette")) {
480  for(const config::attribute& rgb : cp.attribute_range()) {
481  std::vector<color_t> temp;
482  for(const auto& s : utils::split(rgb.second)) {
483  try {
484  temp.push_back(color_t::from_hex_string(s));
485  } catch(const std::invalid_argument&) {
486  ERR_NG << "Invalid color in palette: " << s;
487  }
488  }
489 
490  team_rgb_colors.emplace(rgb.first, temp);
491  LOG_NG << "registered color palette: " << rgb.first;
492  }
493  }
494 }
495 
497 {
498  default_colors.clear();
499  team_rgb_colors.clear();
500  team_rgb_name.clear();
501  team_rgb_range.clear();
502 }
503 
504 const color_range& color_info(std::string_view name)
505 {
506  auto i = team_rgb_range.find(name);
507  if(i != team_rgb_range.end()) {
508  return i->second;
509  }
510 
511  std::vector<color_t> temp;
512  for(const auto& s : utils::split(name)) {
513  try {
514  temp.push_back(color_t::from_hex_string(s));
515  } catch(const std::invalid_argument&) {
516  throw config::error(_("Invalid color in range: ") + s);
517  }
518  }
519 
520  team_rgb_range.emplace(name, color_range(temp));
521  return color_info(name);
522 }
523 
524 const std::vector<color_t>& tc_info(std::string_view name)
525 {
526  auto i = team_rgb_colors.find(name);
527  if(i != team_rgb_colors.end()) {
528  return i->second;
529  }
530 
531  std::vector<color_t> temp;
532  for(const auto& s : utils::split(name)) {
533  try {
534  temp.push_back(color_t::from_hex_string(s));
535  } catch(const std::invalid_argument&) {
536  static std::vector<color_t> stv;
537  ERR_NG << "Invalid color in palette: " << s;
538  return stv;
539  }
540  }
541 
542  team_rgb_colors.emplace(name, temp);
543  return tc_info(name);
544 }
545 
546 color_t red_to_green(double val, bool for_text)
547 {
548  const std::vector<color_t>& color_scale = for_text ? red_green_scale_text : red_green_scale;
549 
550  const double val_scaled = std::clamp(0.01 * val, 0.0, 1.0);
551  const int lvl = std::nearbyint((color_scale.size() - 1) * val_scaled);
552 
553  return color_scale[lvl];
554 }
555 
556 color_t blue_to_white(double val, bool for_text)
557 {
558  const std::vector<color_t>& color_scale = for_text ? blue_white_scale_text : blue_white_scale;
559 
560  const double val_scaled = std::clamp(0.01 * val, 0.0, 1.0);
561  const int lvl = std::nearbyint((color_scale.size() - 1) * val_scaled);
562 
563  return color_scale[lvl];
564 }
565 
567 {
568  std::string ret = _("The Battle for Wesnoth") + " - " + revision;
569  return ret;
570 }
571 
572 } // game_config
A color range definition is made of four reference RGB colors, used for calculating conversions from ...
Definition: color_range.hpp:50
Variant for storing WML attributes.
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:159
child_itors child_range(config_key_type key)
Definition: config.cpp:274
attribute_map::value_type attribute
Definition: config.hpp:299
A class grating read only view to a vector of config objects, viewed as one config with all children ...
static game_config_view wrap(const config &cfg)
config_array_view child_range(config_key_type key) const
std::vector< color_t > palette(const color_range &cr)
Creates a reference color palette from a color range.
Definition: color_range.cpp:85
std::size_t i
Definition: function.cpp:968
static lg::log_domain log_engine("engine")
#define ERR_NG
Definition: game_config.cpp:29
#define LOG_NG
Definition: game_config.cpp:28
Interfaces for manipulating version numbers of engine, add-ons, etc.
static std::string _(const char *str)
Definition: gettext.hpp:93
std::string id
Text to match against addon_info.tags()
Definition: manager.cpp:215
Standard logging facilities (interface).
General math utility functions.
Manage the empty-palette in the editor.
Definition: action.cpp:31
std::string partial_orb_color
std::string moved_orb_color
std::string unmoved_orb_color
std::string ally_orb_color
std::string enemy_orb_color
std::string default_color_list
std::string selected_menu
std::string terrain_mask
std::string victory_laurel_hardest
std::string victory_laurel
std::string orb_two_color
std::string tod_bright
std::string time_icon
std::string selected
std::string app_icon
std::string deselected_menu
std::string observer
std::string ellipsis
std::string unchecked_menu
std::string game_title_background
std::string grid_top
std::string grid_bottom
std::string unreachable
std::string game_title
std::string game_logo
std::string game_logo_background
std::string wml_menu
std::string flag_icon
std::string editor_brush
std::string checked_menu
std::string mouseover
std::string battery_icon
std::string victory_laurel_easy
std::string tod_dark
std::string public_message
std::string private_message
const std::string menu_expand
std::string player_leaves
std::string server_message
std::string game_user_arrive
std::string turn_bell
const std::string menu_contract
std::string game_user_leave
const std::string checkbox_release
std::string timer_bell
std::string friend_message
const std::string menu_select
std::string ready_for_start
std::string game_has_begun
const std::string button_press
std::string game_created
std::string player_joins
const std::string slider_adjust
Game configuration data as global variables.
Definition: build_info.cpp:63
int rest_heal_amount
Definition: game_config.cpp:44
std::vector< std::string > default_defeat_music
std::map< std::string, color_range, std::less<> > team_rgb_range
Colors defined by WML [color_range] tags.
std::string flag_rgb
color_t blue_to_white(double val, bool for_text)
std::map< std::string, t_string, std::less<> > team_rgb_name
const std::size_t max_loop
The maximum number of hexes on a map and items in an array and also used as maximum in wml loops.
Definition: game_config.cpp:70
std::string get_default_title_string()
bool ignore_replay_errors
Definition: game_config.cpp:84
std::string foot_teleport_enter
int village_income
Definition: game_config.cpp:37
bool show_status_on_ally_orb
std::vector< color_t > red_green_scale_text
bool show_moved_orb
std::vector< std::string > foot_speed_prefix
const int gold_carryover_percentage
Default percentage gold carried over to the next scenario.
Definition: game_config.cpp:46
std::string foot_teleport_exit
std::string lobby_music
const std::vector< color_t > & tc_info(std::string_view name)
static std::vector< color_t > blue_white_scale_text
std::string fog_prefix
Definition: game_config.cpp:54
const bool & debug
Definition: game_config.cpp:91
const color_range & color_info(std::string_view name)
std::vector< std::string > default_colors
std::string shroud_prefix
Definition: game_config.cpp:54
double hp_bar_scaling
Definition: game_config.cpp:61
bool disable_autosave
Definition: game_config.cpp:88
std::vector< server_info > server_list
Definition: game_config.cpp:72
int kill_experience
Definition: game_config.cpp:40
std::string unit_rgb
unsigned int tile_size
Definition: game_config.cpp:51
bool show_ally_orb
bool allow_insecure
Definition: game_config.cpp:74
static void add_color_info(const game_config_view &v, bool build_defaults)
bool show_disengaged_orb
std::vector< unsigned int > zoom_levels
Definition: game_config.cpp:56
bool show_partial_orb
std::string title_music
std::string default_terrain
Definition: game_config.cpp:53
bool show_enemy_orb
unsigned lobby_network_timer
Definition: game_config.cpp:67
static std::vector< color_t > blue_white_scale
bool show_unmoved_orb
unsigned lobby_refresh
Definition: game_config.cpp:68
std::vector< std::string > default_victory_music
int combat_experience
Definition: game_config.cpp:41
void reset_color_info()
const std::string revision
void set_debug(bool new_debug)
Definition: game_config.cpp:93
std::vector< color_t > red_green_scale
bool exit_at_end
Definition: game_config.cpp:86
void load_config(const config &v)
color_t red_to_green(double val, bool for_text)
Return a color corresponding to the value val red for val=0.0 to green for val=100....
std::map< std::string, std::vector< color_t >, std::less<> > team_rgb_colors
double xp_bar_scaling
Definition: game_config.cpp:62
int village_support
Definition: game_config.cpp:38
bool get_log_domain_severity(const std::string &name, severity &severity)
Definition: log.cpp:369
severity
Definition: log.hpp:82
bool set_log_domain_severity(const std::string &name, severity severity)
Definition: log.cpp:345
std::vector< std::string > split(const config_attribute_value &val)
The basic class for representing 8-bit RGB or RGBA colour values.
Definition: color.hpp:59
static color_t from_hex_string(const std::string &c)
Creates a new color_t object from a string variable in hex format.
Definition: color.cpp:62
mock_char c
static map_location::DIRECTION s
Some defines: VERSION, PACKAGE, MIN_SAVEGAME_VERSION.
#define e
#define a