OpenTTD Source  20241108-master-g80f628063a
settings_table.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
12 #include "stdafx.h"
13 #include "settings_table.h"
14 #include "currency.h"
15 #include "screenshot.h"
16 #include "network/network.h"
17 #include "network/network_func.h"
18 #include "network/core/config.h"
20 #include "pathfinder/aystar.h"
22 #include "genworld.h"
23 #include "train.h"
24 #include "news_func.h"
25 #include "window_func.h"
26 #include "company_func.h"
28 #if defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA)
29 #define HAS_TRUETYPE_FONT
30 #include "fontcache.h"
31 #endif
32 #include "textbuf_gui.h"
33 #include "rail_gui.h"
34 #include "elrail_func.h"
35 #include "error.h"
36 #include "town.h"
37 #include "video/video_driver.hpp"
38 #include "sound/sound_driver.hpp"
39 #include "music/music_driver.hpp"
40 #include "blitter/factory.hpp"
41 #include "base_media_base.h"
42 #include "ai/ai_config.hpp"
43 #include "ai/ai.hpp"
44 #include "game/game_config.hpp"
45 #include "ship.h"
46 #include "smallmap_gui.h"
47 #include "roadveh.h"
48 #include "roadveh_cmd.h"
49 #include "vehicle_func.h"
50 #include "viewport_func.h"
51 #include "void_map.h"
52 #include "station_func.h"
53 #include "station_base.h"
54 
55 #include "table/strings.h"
56 #include "table/settings.h"
57 
58 #include "safeguards.h"
59 
60 SettingTable _company_settings{ _company_settings_table };
61 SettingTable _currency_settings{ _currency_settings_table };
62 SettingTable _difficulty_settings{ _difficulty_settings_table };
63 SettingTable _multimedia_settings{ _multimedia_settings_table };
64 SettingTable _economy_settings{ _economy_settings_table };
65 SettingTable _game_settings{ _game_settings_table };
66 SettingTable _gui_settings{ _gui_settings_table };
67 SettingTable _linkgraph_settings{ _linkgraph_settings_table };
68 SettingTable _locale_settings{ _locale_settings_table };
69 SettingTable _misc_settings{ _misc_settings_table };
70 SettingTable _network_private_settings{ _network_private_settings_table };
71 SettingTable _network_secrets_settings{ _network_secrets_settings_table };
72 SettingTable _network_settings{ _network_settings_table };
73 SettingTable _news_display_settings{ _news_display_settings_table };
74 SettingTable _old_gameopt_settings{ _old_gameopt_settings_table };
75 SettingTable _pathfinding_settings{ _pathfinding_settings_table };
76 SettingTable _script_settings{ _script_settings_table };
77 SettingTable _window_settings{ _window_settings_table };
78 SettingTable _world_settings{ _world_settings_table };
79 #if defined(_WIN32) && !defined(DEDICATED)
80 SettingTable _win32_settings{ _win32_settings_table };
81 #endif /* _WIN32 */
82 
83 
84 /* Begin - Callback Functions for the various settings. */
85 
88 {
89  return TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU) ? sd.str + 1 : sd.str;
90 }
91 
94 {
95  return TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU) ? sd.str_help + 1 : sd.str_help;
96 }
97 
99 static void SettingsValueVelocityUnit(const IntSettingDesc &, uint first_param, int32_t value)
100 {
101  StringID val;
102  switch (value) {
103  case 0: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_IMPERIAL; break;
104  case 1: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_METRIC; break;
105  case 2: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_SI; break;
106  case 3: val = TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU) ? STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_GAMEUNITS_SECS : STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_GAMEUNITS_DAYS; break;
107  case 4: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_KNOTS; break;
108  default: NOT_REACHED();
109  }
110  SetDParam(first_param, val);
111 }
112 
114 static void SettingsValueAbsolute(const IntSettingDesc &sd, uint first_param, int32_t value)
115 {
116  SetDParam(first_param, sd.str_val + ((value >= 0) ? 1 : 0));
117  SetDParam(first_param + 1, abs(value));
118 }
119 
121 static void ServiceIntervalSettingsValueText(const IntSettingDesc &sd, uint first_param, int32_t value)
122 {
124  if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
126  } else {
127  vds = &Company::Get(_current_company)->settings.vehicle;
128  }
129 
130  if (value == 0) {
131  SetDParam(first_param, sd.str_val + 3);
132  } else if (vds->servint_ispercent) {
133  SetDParam(first_param, sd.str_val + 2);
134  } else if (TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU)) {
135  SetDParam(first_param, sd.str_val + 1);
136  } else {
137  SetDParam(first_param, sd.str_val);
138  }
139  SetDParam(first_param + 1, value);
140 }
141 
143 static void v_PositionMainToolbar(int32_t)
144 {
145  if (_game_mode != GM_MENU) PositionMainToolbar(nullptr);
146 }
147 
149 static void v_PositionStatusbar(int32_t)
150 {
151  if (_game_mode != GM_MENU) {
152  PositionStatusbar(nullptr);
153  PositionNewsMessage(nullptr);
154  PositionNetworkChatWindow(nullptr);
155  }
156 }
157 
161 static void RedrawSmallmap(int32_t)
162 {
163  BuildLandLegend();
166 }
167 
169 static void UpdateLinkgraphColours(int32_t)
170 {
173 }
174 
175 static void StationSpreadChanged(int32_t)
176 {
179 }
180 
181 static void UpdateConsists(int32_t)
182 {
183  for (Train *t : Train::Iterate()) {
184  /* Update the consist of all trains so the maximum speed is set correctly. */
185  if (t->IsFrontEngine() || t->IsFreeWagon()) t->ConsistChanged(CCF_TRACK);
186  }
188 }
189 
194 static void UpdateAllServiceInterval(int32_t new_value)
195 {
196  bool update_vehicles;
198  if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
200  update_vehicles = false;
201  } else {
202  vds = &Company::Get(_current_company)->settings.vehicle;
203  update_vehicles = true;
204  }
205 
206  if (new_value != 0) {
207  /* Service intervals are in percents. */
208  vds->servint_trains = DEF_SERVINT_PERCENT;
209  vds->servint_roadveh = DEF_SERVINT_PERCENT;
210  vds->servint_aircraft = DEF_SERVINT_PERCENT;
211  vds->servint_ships = DEF_SERVINT_PERCENT;
212  } else if (TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU)) {
213  /* Service intervals are in minutes. */
214  vds->servint_trains = DEF_SERVINT_MINUTES_TRAINS;
215  vds->servint_roadveh = DEF_SERVINT_MINUTES_ROADVEH;
216  vds->servint_aircraft = DEF_SERVINT_MINUTES_AIRCRAFT;
217  vds->servint_ships = DEF_SERVINT_MINUTES_SHIPS;
218  } else {
219  /* Service intervals are in days. */
220  vds->servint_trains = DEF_SERVINT_DAYS_TRAINS;
221  vds->servint_roadveh = DEF_SERVINT_DAYS_ROADVEH;
222  vds->servint_aircraft = DEF_SERVINT_DAYS_AIRCRAFT;
223  vds->servint_ships = DEF_SERVINT_DAYS_SHIPS;
224  }
225 
226  if (update_vehicles) {
228  for (Vehicle *v : Vehicle::Iterate()) {
229  if (v->owner == _current_company && v->IsPrimaryVehicle() && !v->ServiceIntervalIsCustom()) {
230  v->SetServiceInterval(CompanyServiceInterval(c, v->type));
231  v->SetServiceIntervalIsPercent(new_value != 0);
232  }
233  }
234  }
235 
237 }
238 
239 static bool CanUpdateServiceInterval(VehicleType, int32_t &new_value)
240 {
242  if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
244  } else {
245  vds = &Company::Get(_current_company)->settings.vehicle;
246  }
247 
248  /* Test if the interval is valid */
249  int32_t interval = GetServiceIntervalClamped(new_value, vds->servint_ispercent);
250  return interval == new_value;
251 }
252 
253 static void UpdateServiceInterval(VehicleType type, int32_t new_value)
254 {
255  if (_game_mode != GM_MENU && Company::IsValidID(_current_company)) {
256  for (Vehicle *v : Vehicle::Iterate()) {
257  if (v->owner == _current_company && v->type == type && v->IsPrimaryVehicle() && !v->ServiceIntervalIsCustom()) {
258  v->SetServiceInterval(new_value);
259  }
260  }
261  }
262 
264 }
265 
271 {
273  if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
275  } else {
276  vds = &Company::Get(_current_company)->settings.vehicle;
277  }
278 
279  int32_t new_value;
280  if (vds->servint_ispercent) {
281  new_value = DEF_SERVINT_PERCENT;
282  } else if (TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU)) {
283  switch (type) {
284  case VEH_TRAIN: new_value = DEF_SERVINT_MINUTES_TRAINS; break;
285  case VEH_ROAD: new_value = DEF_SERVINT_MINUTES_ROADVEH; break;
286  case VEH_AIRCRAFT: new_value = DEF_SERVINT_MINUTES_AIRCRAFT; break;
287  case VEH_SHIP: new_value = DEF_SERVINT_MINUTES_SHIPS; break;
288  default: NOT_REACHED();
289  }
290  } else {
291  switch (type) {
292  case VEH_TRAIN: new_value = DEF_SERVINT_DAYS_TRAINS; break;
293  case VEH_ROAD: new_value = DEF_SERVINT_DAYS_ROADVEH; break;
294  case VEH_AIRCRAFT: new_value = DEF_SERVINT_DAYS_AIRCRAFT; break;
295  case VEH_SHIP: new_value = DEF_SERVINT_DAYS_SHIPS; break;
296  default: NOT_REACHED();
297  }
298  }
299 
300  return new_value;
301 }
302 
303 static void TrainAccelerationModelChanged(int32_t)
304 {
305  for (Train *t : Train::Iterate()) {
306  if (t->IsFrontEngine()) {
307  t->tcache.cached_max_curve_speed = t->GetCurveSpeedLimit();
308  t->UpdateAcceleration();
309  }
310  }
311 
312  /* These windows show acceleration values only when realistic acceleration is on. They must be redrawn after a setting change. */
316 }
317 
321 static void TrainSlopeSteepnessChanged(int32_t)
322 {
323  for (Train *t : Train::Iterate()) {
324  if (t->IsFrontEngine()) t->CargoChanged();
325  }
326 }
327 
332 {
334  for (RoadVehicle *rv : RoadVehicle::Iterate()) {
335  if (rv->IsFrontEngine()) {
336  rv->CargoChanged();
337  }
338  }
339  }
340 
341  /* These windows show acceleration values only when realistic acceleration is on. They must be redrawn after a setting change. */
345 }
346 
350 static void RoadVehSlopeSteepnessChanged(int32_t)
351 {
352  for (RoadVehicle *rv : RoadVehicle::Iterate()) {
353  if (rv->IsFrontEngine()) rv->CargoChanged();
354  }
355 }
356 
357 static void TownFoundingChanged(int32_t)
358 {
359  if (_game_mode != GM_EDITOR && _settings_game.economy.found_town == TF_FORBIDDEN) {
361  } else {
363  }
364 }
365 
366 static void ZoomMinMaxChanged(int32_t)
367 {
368  ConstrainAllViewportsZoom();
371  if (AdjustGUIZoom(false)) {
372  ReInitAllWindows(true);
373  }
374 }
375 
376 static void SpriteZoomMinChanged(int32_t)
377 {
379  /* Force all sprites to redraw at the new chosen zoom level */
381 }
382 
388 static void InvalidateNewGRFChangeWindows(int32_t)
389 {
392  ReInitAllWindows(false);
393 }
394 
395 static void InvalidateCompanyLiveryWindow(int32_t)
396 {
398  ResetVehicleColourMap();
399 }
400 
401 static void DifficultyNoiseChange(int32_t)
402 {
403  if (_game_mode == GM_NORMAL) {
407  }
408  }
409 }
410 
411 static void MaxNoAIsChange(int32_t)
412 {
413  if (GetGameSettings().difficulty.max_no_competitors != 0 &&
414  AI::GetInfoList()->empty() &&
416  ShowErrorMessage(STR_WARNING_NO_SUITABLE_AI, INVALID_STRING_ID, WL_CRITICAL);
417  }
418 
420 }
421 
426 static bool CheckRoadSide(int32_t &)
427 {
428  return _game_mode == GM_MENU || !RoadVehiclesAreBuilt();
429 }
430 
438 static size_t ConvertLandscape(const char *value)
439 {
440  /* try with the old values */
441  static std::vector<std::string> _old_landscape_values{"normal", "hilly", "desert", "candy"};
442  return OneOfManySettingDesc::ParseSingleValue(value, strlen(value), _old_landscape_values);
443 }
444 
445 static bool CheckFreeformEdges(int32_t &new_value)
446 {
447  if (_game_mode == GM_MENU) return true;
448  if (new_value != 0) {
449  for (Ship *s : Ship::Iterate()) {
450  /* Check if there is a ship on the northern border. */
451  if (TileX(s->tile) == 0 || TileY(s->tile) == 0) {
452  ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_EMPTY, INVALID_STRING_ID, WL_ERROR);
453  return false;
454  }
455  }
456  for (const BaseStation *st : BaseStation::Iterate()) {
457  /* Check if there is a non-deleted buoy on the northern border. */
458  if (st->IsInUse() && (TileX(st->xy) == 0 || TileY(st->xy) == 0)) {
459  ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_EMPTY, INVALID_STRING_ID, WL_ERROR);
460  return false;
461  }
462  }
463  } else {
464  for (uint i = 0; i < Map::MaxX(); i++) {
465  if (TileHeight(TileXY(i, 1)) != 0) {
466  ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
467  return false;
468  }
469  }
470  for (uint i = 1; i < Map::MaxX(); i++) {
471  if (!IsTileType(TileXY(i, Map::MaxY() - 1), MP_WATER) || TileHeight(TileXY(1, Map::MaxY())) != 0) {
472  ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
473  return false;
474  }
475  }
476  for (uint i = 0; i < Map::MaxY(); i++) {
477  if (TileHeight(TileXY(1, i)) != 0) {
478  ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
479  return false;
480  }
481  }
482  for (uint i = 1; i < Map::MaxY(); i++) {
483  if (!IsTileType(TileXY(Map::MaxX() - 1, i), MP_WATER) || TileHeight(TileXY(Map::MaxX(), i)) != 0) {
484  ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
485  return false;
486  }
487  }
488  }
489  return true;
490 }
491 
492 static void UpdateFreeformEdges(int32_t new_value)
493 {
494  if (_game_mode == GM_MENU) return;
495 
496  if (new_value != 0) {
497  for (uint x = 0; x < Map::SizeX(); x++) MakeVoid(TileXY(x, 0));
498  for (uint y = 0; y < Map::SizeY(); y++) MakeVoid(TileXY(0, y));
499  } else {
500  /* Make tiles at the border water again. */
501  for (uint i = 0; i < Map::MaxX(); i++) {
502  SetTileHeight(TileXY(i, 0), 0);
503  SetTileType(TileXY(i, 0), MP_WATER);
504  }
505  for (uint i = 0; i < Map::MaxY(); i++) {
506  SetTileHeight(TileXY(0, i), 0);
507  SetTileType(TileXY(0, i), MP_WATER);
508  }
509  }
511 }
512 
517 static bool CheckDynamicEngines(int32_t &)
518 {
519  if (_game_mode == GM_MENU) return true;
520 
522  ShowErrorMessage(STR_CONFIG_SETTING_DYNAMIC_ENGINES_EXISTING_VEHICLES, INVALID_STRING_ID, WL_ERROR);
523  return false;
524  }
525 
526  return true;
527 }
528 
529 static bool CheckMaxHeightLevel(int32_t &new_value)
530 {
531  if (_game_mode == GM_NORMAL) return false;
532  if (_game_mode != GM_EDITOR) return true;
533 
534  /* Check if at least one mountain on the map is higher than the new value.
535  * If yes, disallow the change. */
536  for (TileIndex t = 0; t < Map::Size(); t++) {
537  if ((int32_t)TileHeight(t) > new_value) {
538  ShowErrorMessage(STR_CONFIG_SETTING_TOO_HIGH_MOUNTAIN, INVALID_STRING_ID, WL_ERROR);
539  /* Return old, unchanged value */
540  return false;
541  }
542  }
543 
544  return true;
545 }
546 
547 static void StationCatchmentChanged(int32_t)
548 {
551 }
552 
553 static void MaxVehiclesChanged(int32_t)
554 {
557 }
558 
564 static bool ReplaceAsteriskWithEmptyPassword(std::string &newval)
565 {
566  if (newval.compare("*") == 0) newval.clear();
567  return true;
568 }
569 
572 {
574 
576 
577  if (_network_server) {
579  }
580 }
581 
586 static void ChangeTimekeepingUnits(int32_t)
587 {
588  /* If service intervals are in time units (calendar days or real-world minutes), reset them to the correct defaults. */
591  }
592 
593  /* If we are using calendar timekeeping, "minutes per year" must be default. */
595  _settings_newgame.economy.minutes_per_calendar_year = CalendarTime::DEF_MINUTES_PER_YEAR;
596  }
597 
599 
600  /* It is possible to change these units in Scenario Editor. We must set the economy date appropriately. */
601  if (_game_mode == GM_EDITOR) {
602  TimerGameEconomy::Date new_economy_date;
603  TimerGameEconomy::DateFract new_economy_date_fract;
604 
606  /* If the new mode is wallclock units, set the economy year back to 1. */
607  new_economy_date = TimerGameEconomy::ConvertYMDToDate(1, 0, 1);
608  new_economy_date_fract = 0;
609  } else {
610  /* If the new mode is calendar units, sync the economy year with the calendar year. */
611  new_economy_date = TimerGameCalendar::date.base();
612  new_economy_date_fract = TimerGameCalendar::date_fract;
613  }
614 
615  /* If you open a savegame as a scenario, there may already be link graphs and/or vehicles. These use economy date. */
617  for (auto v : Vehicle::Iterate()) v->ShiftDates(new_economy_date - TimerGameEconomy::date);
618 
619  /* Only change the date after changing cached values above. */
620  TimerGameEconomy::SetDate(new_economy_date, new_economy_date_fract);
621  }
622 }
623 
628 static void ChangeMinutesPerYear(int32_t new_value)
629 {
630  /* We don't allow setting Minutes Per Year below default, unless it's to 0 for frozen calendar time. */
631  if (new_value < CalendarTime::DEF_MINUTES_PER_YEAR) {
632  int clamped;
633 
634  /* If the new value is 1, we're probably at 0 and trying to increase the value, so we should jump up to default. */
635  if (new_value == 1) {
636  clamped = CalendarTime::DEF_MINUTES_PER_YEAR;
637  } else {
638  clamped = CalendarTime::FROZEN_MINUTES_PER_YEAR;
639  }
640 
641  /* Override the setting with the clamped value. */
642  if (_game_mode == GM_MENU) {
644  } else {
646  }
647  }
648 
649  /* If the setting value is not the default, force the game to use wallclock timekeeping units.
650  * This can only happen in the menu, since the pre_cb ensures this setting can only be changed there, or if we're already using wallclock units.
651  */
652  if (_game_mode == GM_MENU && (_settings_newgame.economy.minutes_per_calendar_year != CalendarTime::DEF_MINUTES_PER_YEAR)) {
655  }
656 }
657 
663 static bool CanChangeTimetableMode(int32_t &)
664 {
666 }
667 
668 /* End - Callback Functions */
Base functions for all AIs.
AIConfig stores the configuration settings of every AI.
This file has the header for AyStar.
Generic functions for replacing base data (graphics, sounds).
static const ScriptInfoList * GetInfoList()
Wrapper function for AIScanner::GetAIInfoList.
Definition: ai_core.cpp:306
static LinkGraphSchedule instance
Static instance of LinkGraphSchedule.
void ShiftDates(TimerGameEconomy::Date interval)
Shift all dates (join dates and edge annotations) of link graphs and link graph jobs by the number of...
static Date date
Current date in days (day counter).
static DateFract date_fract
Fractional part of the day.
static Date date
Current date in days (day counter).
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
static void SetDate(Date date, DateFract fract)
Set the date.
static Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
uint16_t DateFract
The fraction of a date we're in, i.e.
int CompanyServiceInterval(const Company *c, VehicleType type)
Get the service interval for the given company and vehicle type.
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:53
Functions related to companies.
Configuration options of the network stuff.
Functions to handle different currencies.
header file for electrified rail specific functions
Functions related to errors.
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
Definition: error_gui.cpp:367
@ WL_ERROR
Errors (eg. saving/loading failed)
Definition: error.h:26
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:27
Factory to 'query' all available blitters.
Functions to read fonts from files and cache them.
GameConfig stores the configuration settings of every Game.
Functions related to world/map generation.
bool AdjustGUIZoom(bool automatic)
Resolve GUI zoom level and adjust GUI to new zoom, if auto-suggestion is requested.
Definition: gfx.cpp:1793
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1529
Declaration of link graph schedule used for cargo distribution.
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:373
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:425
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:415
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:23
Base for all music playback.
bool _networking
are we in networking mode?
Definition: network.cpp:65
bool _network_server
network-server is active
Definition: network.cpp:66
Basic functions/variables used all over the place.
Network functions used by other parts of OpenTTD.
void NetworkServerUpdateGameInfo()
Update the server's NetworkServerGameInfo due to changes in settings.
void NetworkServerSendConfigUpdate()
Send Config Update.
Functions related to news.
uint16_t GetServiceIntervalClamped(int interval, bool ispercent)
Clamp the service interval to the correct min/max.
Definition: order_cmd.cpp:1901
General types related to pathfinders.
Functions/types etc.
bool RoadVehiclesAreBuilt()
Verify whether a road vehicle is available.
Definition: road_cmd.cpp:179
Road vehicle states.
Command definitions related to road vehicles.
A number of safeguards to prevent using unsafe methods.
Functions to make screenshots.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:57
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition: settings.cpp:58
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:56
static void RoadVehSlopeSteepnessChanged(int32_t)
This function updates the road vehicle acceleration cache after a steepness change.
static void RoadVehAccelerationModelChanged(int32_t)
This function updates realistic acceleration caches when the setting "Road vehicle acceleration model...
static void UpdateAllServiceInterval(int32_t new_value)
Check and update if needed all vehicle service intervals.
static void v_PositionStatusbar(int32_t)
Reposition the statusbar as the setting changed.
static void TrainSlopeSteepnessChanged(int32_t)
This function updates the train acceleration cache after a steepness change.
static void UpdateLinkgraphColours(int32_t)
Redraw linkgraph links after a colour scheme change.
static void RedrawSmallmap(int32_t)
Redraw the smallmap after a colour scheme change.
static bool ReplaceAsteriskWithEmptyPassword(std::string &newval)
Replace a passwords that are a literal asterisk with an empty string.
static void ServiceIntervalSettingsValueText(const IntSettingDesc &sd, uint first_param, int32_t value)
Service Interval Settings Default Value displays the correct units or as a percentage.
static StringID SettingHelpWallclock(const IntSettingDesc &sd)
Switch setting help depending on wallclock setting.
static bool CheckDynamicEngines(int32_t &)
Changing the setting "allow multiple NewGRF sets" is not allowed if there are vehicles.
static bool CheckRoadSide(int32_t &)
Check whether the road side may be changed.
static void v_PositionMainToolbar(int32_t)
Reposition the main toolbar as the setting changed.
static void SettingsValueAbsolute(const IntSettingDesc &sd, uint first_param, int32_t value)
A negative value has another string (the one after "strval").
static int32_t GetDefaultServiceInterval(VehicleType type)
Checks if the service intervals in the settings are specified as percentages and corrects the default...
static size_t ConvertLandscape(const char *value)
Conversion callback for _gameopt_settings_game.landscape It converts (or try) between old values and ...
static bool CanChangeTimetableMode(int32_t &)
Pre-callback check when trying to change the timetable mode.
static void UpdateClientConfigValues()
Update the game info, and send it to the clients when we are running as a server.
static void ChangeMinutesPerYear(int32_t new_value)
Callback after the player changes the minutes per year.
static StringID SettingTitleWallclock(const IntSettingDesc &sd)
Switch setting title depending on wallclock setting.
static void ChangeTimekeepingUnits(int32_t)
Callback for when the player changes the timekeeping units.
static void InvalidateNewGRFChangeWindows(int32_t)
Update any possible saveload window and delete any newgrf dialogue as its widget parts might change.
static void SettingsValueVelocityUnit(const IntSettingDesc &, uint first_param, int32_t value)
Setting values for velocity unit localisation.
Definition of the configuration tables of the settings.
GameSettings & GetGameSettings()
Get the settings-object applicable for the current situation: the newgame settings when we're in the ...
Base for ships.
void BuildLandLegend()
(Re)build the colour tables for the legends.
void BuildOwnerLegend()
Completes the array for the owned property legend.
void BuildLinkStatsLegend()
Populate legend table for the link stat view.
Smallmap GUI functions.
Base for all sound drivers.
void GfxClearSpriteCache()
Remove all encoded sprites from the sprite cache without discarding sprite location information.
Base classes/functions for stations.
void UpdateAirportsNoise()
Recalculate the noise generated by the airports of each town.
Functions related to stations.
Definition of base types and functions in a cross-platform compatible way.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings.cpp:104
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
Base class for all station-ish types.
CompanySettings company
default values for per-company settings
VehicleDefaultSettings vehicle
default settings for vehicles
TownFounding found_town
town founding.
TimekeepingUnits timekeeping_units
time units to use for the game economy, either calendar or wallclock
bool station_noise_level
build new airports when the town noise level is still within accepted limits
uint16_t minutes_per_calendar_year
minutes per calendar year. Special value 0 means that calendar time is frozen.
static bool ResetToCurrentNewGRFConfig()
Tries to reset the engine mapping to match the current NewGRF configuration.
Definition: engine.cpp:549
EconomySettings economy
settings to change the economy
VehicleSettings vehicle
options for vehicles
Base integer type, including boolean, settings.
StringID str_help
(Translated) string with help text; gui only.
StringID str_val
(Translated) first string describing the value.
StringID str
(translated) string with descriptive text; gui and console
static uint SizeY()
Get the size of the map along the Y.
Definition: map_func.h:279
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition: map_func.h:270
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:306
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:297
static size_t ParseSingleValue(const char *str, size_t len, const std::vector< std::string > &many)
Find the index value of a ONEofMANY type in a string separated by |.
Definition: settings.cpp:185
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:328
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
Buses, trucks and trams belong to this class.
Definition: roadveh.h:106
All ships have this type.
Definition: ship.h:24
static Pool::IterateWrapper< T > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
static void RecomputeCatchmentForAll()
Recomputes catchment of all stations.
Definition: station.cpp:530
'Train' is either a loco or a wagon.
Definition: train.h:89
Default settings for vehicles.
uint16_t servint_aircraft
service interval for aircraft
uint16_t servint_roadveh
service interval for road vehicles
uint16_t servint_ships
service interval for ships
bool servint_ispercent
service intervals are in percents
uint16_t servint_trains
service interval for trains
uint8_t roadveh_acceleration_model
realistic acceleration for road vehicles
Vehicle data structure.
Definition: vehicle_base.h:244
Stuff related to the text buffer GUI.
void SetTileType(Tile tile, TileType type)
Set the type of a tile.
Definition: tile_map.h:131
void SetTileHeight(Tile tile, uint height)
Sets the height of a tile.
Definition: tile_map.h:57
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
Definition: tile_map.h:29
@ MP_WATER
Water tile.
Definition: tile_type.h:54
Definition of the game-calendar-timer.
Base of the town class.
@ TF_FORBIDDEN
Forbidden.
Definition: town_type.h:95
Base for the train class.
@ CCF_TRACK
Valid changes while vehicle is driving, and possibly changing tracks.
Definition: train.h:48
Functions related to vehicles.
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Base of all video drivers.
Functions related to (drawing on) viewports.
Map accessors for void tiles.
void MakeVoid(Tile t)
Make a nice void tile ;)
Definition: void_map.h:19
int PositionStatusbar(Window *w)
(Re)position statusbar window at the screen.
Definition: window.cpp:3393
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1140
int PositionMainToolbar(Window *w)
(Re)position main toolbar window at the screen.
Definition: window.cpp:3382
int PositionNetworkChatWindow(Window *w)
(Re)position network chat window at the screen.
Definition: window.cpp:3415
void ReInitAllWindows(bool zoom_changed)
Re-initialize all windows.
Definition: window.cpp:3327
void CloseWindowByClass(WindowClass cls, int data)
Close all windows of a given class.
Definition: window.cpp:1152
int PositionNewsMessage(Window *w)
(Re)position news message window at the screen.
Definition: window.cpp:3404
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3119
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3211
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3228
Window functions not directly related to making/drawing windows.
@ WC_BUILD_STATION
Build station; Window numbers:
Definition: window_type.h:403
@ WC_SPRITE_ALIGNER
Sprite aligner (debug); Window numbers:
Definition: window_type.h:686
@ WC_COMPANY_COLOUR
Company colour selection; Window numbers:
Definition: window_type.h:230
@ WC_FOUND_TOWN
Found a town; Window numbers:
Definition: window_type.h:435
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition: window_type.h:73
@ WC_SELECT_STATION
Select station (when joining stations); Window numbers:
Definition: window_type.h:242
@ WC_ENGINE_PREVIEW
Engine preview window; Window numbers:
Definition: window_type.h:600
@ WC_CLIENT_LIST
Client list; Window numbers:
Definition: window_type.h:484
@ WC_TOWN_VIEW
Town view; Window numbers:
Definition: window_type.h:333
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition: window_type.h:624
@ WC_SMALLMAP
Small map; Window numbers:
Definition: window_type.h:104
@ WC_SAVELOAD
Saveload window; Window numbers:
Definition: window_type.h:144
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:200
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers:
Definition: window_type.h:389