OpenTTD Source 20250205-master-gfd85ab1e2c
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"
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"
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
60SettingTable _company_settings{ _company_settings_table };
61SettingTable _currency_settings{ _currency_settings_table };
62SettingTable _difficulty_settings{ _difficulty_settings_table };
63SettingTable _multimedia_settings{ _multimedia_settings_table };
64SettingTable _economy_settings{ _economy_settings_table };
65SettingTable _game_settings{ _game_settings_table };
66SettingTable _gui_settings{ _gui_settings_table };
67SettingTable _linkgraph_settings{ _linkgraph_settings_table };
68SettingTable _locale_settings{ _locale_settings_table };
69SettingTable _misc_settings{ _misc_settings_table };
70SettingTable _network_private_settings{ _network_private_settings_table };
71SettingTable _network_secrets_settings{ _network_secrets_settings_table };
72SettingTable _network_settings{ _network_settings_table };
73SettingTable _news_display_settings{ _news_display_settings_table };
74SettingTable _old_gameopt_settings{ _old_gameopt_settings_table };
75SettingTable _pathfinding_settings{ _pathfinding_settings_table };
76SettingTable _script_settings{ _script_settings_table };
77SettingTable _window_settings{ _window_settings_table };
78SettingTable _world_settings{ _world_settings_table };
79#if defined(_WIN32) && !defined(DEDICATED)
80SettingTable _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
99static 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
114static 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
121static 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
143static void v_PositionMainToolbar(int32_t)
144{
145 if (_game_mode != GM_MENU) PositionMainToolbar(nullptr);
146}
147
149static void v_PositionStatusbar(int32_t)
150{
151 if (_game_mode != GM_MENU) {
152 PositionStatusbar(nullptr);
153 PositionNewsMessage(nullptr);
155 }
156}
157
161static void RedrawSmallmap(int32_t)
162{
166}
167
169static void UpdateLinkgraphColours(int32_t)
170{
173}
174
175static void StationSpreadChanged(int32_t)
176{
179}
180
181static 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
194static 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
239static 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 new_value == 0 || interval == new_value;
251}
252
253static 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
270{
272 if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
274 } else {
275 vds = &Company::Get(_current_company)->settings.vehicle;
276 }
277
278 if (vds->servint_ispercent) return DEF_SERVINT_PERCENT;
279
280 if (TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU)) {
281 switch (type) {
282 case VEH_TRAIN: return DEF_SERVINT_MINUTES_TRAINS;
283 case VEH_ROAD: return DEF_SERVINT_MINUTES_ROADVEH;
284 case VEH_AIRCRAFT: return DEF_SERVINT_MINUTES_AIRCRAFT;
285 case VEH_SHIP: return DEF_SERVINT_MINUTES_SHIPS;
286 default: NOT_REACHED();
287 }
288 }
289
290 return sd.def;
291}
292
293static std::tuple<int32_t, uint32_t> GetServiceIntervalRange(const IntSettingDesc &)
294{
296 if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
298 } else {
299 vds = &Company::Get(_current_company)->settings.vehicle;
300 }
301
302 if (vds->servint_ispercent) return { MIN_SERVINT_PERCENT, MAX_SERVINT_PERCENT };
303
304 if (TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU)) {
305 return { MIN_SERVINT_MINUTES, MAX_SERVINT_MINUTES };
306 }
307
308 return { MIN_SERVINT_DAYS, MAX_SERVINT_DAYS };
309}
310
311static void TrainAccelerationModelChanged(int32_t)
312{
313 for (Train *t : Train::Iterate()) {
314 if (t->IsFrontEngine()) {
315 t->tcache.cached_max_curve_speed = t->GetCurveSpeedLimit();
316 t->UpdateAcceleration();
317 }
318 }
319
320 /* These windows show acceleration values only when realistic acceleration is on. They must be redrawn after a setting change. */
324}
325
329static void TrainSlopeSteepnessChanged(int32_t)
330{
331 for (Train *t : Train::Iterate()) {
332 if (t->IsFrontEngine()) t->CargoChanged();
333 }
334}
335
340{
342 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
343 if (rv->IsFrontEngine()) {
344 rv->CargoChanged();
345 }
346 }
347 }
348
349 /* These windows show acceleration values only when realistic acceleration is on. They must be redrawn after a setting change. */
353}
354
359{
360 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
361 if (rv->IsFrontEngine()) rv->CargoChanged();
362 }
363}
364
365static void TownFoundingChanged(int32_t)
366{
367 if (_game_mode != GM_EDITOR && _settings_game.economy.found_town == TF_FORBIDDEN) {
369 } else {
371 }
372}
373
374static void ZoomMinMaxChanged(int32_t)
375{
376 ConstrainAllViewportsZoom();
379 if (AdjustGUIZoom(false)) {
380 ReInitAllWindows(true);
381 }
382}
383
384static void SpriteZoomMinChanged(int32_t)
385{
387 /* Force all sprites to redraw at the new chosen zoom level */
389}
390
402
403static void InvalidateCompanyLiveryWindow(int32_t)
404{
406 ResetVehicleColourMap();
407}
408
409static void DifficultyNoiseChange(int32_t)
410{
411 if (_game_mode == GM_NORMAL) {
415 }
416 }
417}
418
419static void MaxNoAIsChange(int32_t)
420{
421 if (GetGameSettings().difficulty.max_no_competitors != 0 &&
422 AI::GetInfoList()->empty() &&
424 ShowErrorMessage(STR_WARNING_NO_SUITABLE_AI, INVALID_STRING_ID, WL_CRITICAL);
425 }
426
428}
429
434static bool CheckRoadSide(int32_t &)
435{
436 return _game_mode == GM_MENU || !RoadVehiclesAreBuilt();
437}
438
446static size_t ConvertLandscape(const char *value)
447{
448 /* try with the old values */
449 static std::vector<std::string> _old_landscape_values{"normal", "hilly", "desert", "candy"};
450 return OneOfManySettingDesc::ParseSingleValue(value, strlen(value), _old_landscape_values);
451}
452
453static bool CheckFreeformEdges(int32_t &new_value)
454{
455 if (_game_mode == GM_MENU) return true;
456 if (new_value != 0) {
457 for (Ship *s : Ship::Iterate()) {
458 /* Check if there is a ship on the northern border. */
459 if (TileX(s->tile) == 0 || TileY(s->tile) == 0) {
460 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_EMPTY, INVALID_STRING_ID, WL_ERROR);
461 return false;
462 }
463 }
464 for (const BaseStation *st : BaseStation::Iterate()) {
465 /* Check if there is a non-deleted buoy on the northern border. */
466 if (st->IsInUse() && (TileX(st->xy) == 0 || TileY(st->xy) == 0)) {
467 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_EMPTY, INVALID_STRING_ID, WL_ERROR);
468 return false;
469 }
470 }
471 } else {
472 for (uint i = 0; i < Map::MaxX(); i++) {
473 if (TileHeight(TileXY(i, 1)) != 0) {
474 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
475 return false;
476 }
477 }
478 for (uint i = 1; i < Map::MaxX(); i++) {
479 if (!IsTileType(TileXY(i, Map::MaxY() - 1), MP_WATER) || TileHeight(TileXY(1, Map::MaxY())) != 0) {
480 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
481 return false;
482 }
483 }
484 for (uint i = 0; i < Map::MaxY(); i++) {
485 if (TileHeight(TileXY(1, i)) != 0) {
486 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
487 return false;
488 }
489 }
490 for (uint i = 1; i < Map::MaxY(); i++) {
491 if (!IsTileType(TileXY(Map::MaxX() - 1, i), MP_WATER) || TileHeight(TileXY(Map::MaxX(), i)) != 0) {
492 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
493 return false;
494 }
495 }
496 }
497 return true;
498}
499
500static void UpdateFreeformEdges(int32_t new_value)
501{
502 if (_game_mode == GM_MENU) return;
503
504 if (new_value != 0) {
505 for (uint x = 0; x < Map::SizeX(); x++) MakeVoid(TileXY(x, 0));
506 for (uint y = 0; y < Map::SizeY(); y++) MakeVoid(TileXY(0, y));
507 } else {
508 /* Make tiles at the border water again. */
509 for (uint i = 0; i < Map::MaxX(); i++) {
510 SetTileHeight(TileXY(i, 0), 0);
512 }
513 for (uint i = 0; i < Map::MaxY(); i++) {
514 SetTileHeight(TileXY(0, i), 0);
516 }
517 }
519}
520
525static bool CheckDynamicEngines(int32_t &)
526{
527 if (_game_mode == GM_MENU) return true;
528
530 ShowErrorMessage(STR_CONFIG_SETTING_DYNAMIC_ENGINES_EXISTING_VEHICLES, INVALID_STRING_ID, WL_ERROR);
531 return false;
532 }
533
534 return true;
535}
536
537static bool CheckMaxHeightLevel(int32_t &new_value)
538{
539 if (_game_mode == GM_NORMAL) return false;
540 if (_game_mode != GM_EDITOR) return true;
541
542 /* Check if at least one mountain on the map is higher than the new value.
543 * If yes, disallow the change. */
544 for (const auto t : Map::Iterate()) {
545 if ((int32_t)TileHeight(t) > new_value) {
546 ShowErrorMessage(STR_CONFIG_SETTING_TOO_HIGH_MOUNTAIN, INVALID_STRING_ID, WL_ERROR);
547 /* Return old, unchanged value */
548 return false;
549 }
550 }
551
552 return true;
553}
554
555static void StationCatchmentChanged(int32_t)
556{
559}
560
561static void MaxVehiclesChanged(int32_t)
562{
565}
566
572static bool ReplaceAsteriskWithEmptyPassword(std::string &newval)
573{
574 if (newval.compare("*") == 0) newval.clear();
575 return true;
576}
577
589
594static void ChangeTimekeepingUnits(int32_t)
595{
596 /* If service intervals are in time units (calendar days or real-world minutes), reset them to the correct defaults. */
599 }
600
601 /* If we are using calendar timekeeping, "minutes per year" must be default. */
603 _settings_newgame.economy.minutes_per_calendar_year = CalendarTime::DEF_MINUTES_PER_YEAR;
604 }
605
607
608 /* It is possible to change these units in Scenario Editor. We must set the economy date appropriately. */
609 if (_game_mode == GM_EDITOR) {
610 TimerGameEconomy::Date new_economy_date;
611 TimerGameEconomy::DateFract new_economy_date_fract;
612
614 /* If the new mode is wallclock units, set the economy year back to 1. */
615 new_economy_date = TimerGameEconomy::ConvertYMDToDate(TimerGameEconomy::Year{1}, 0, 1);
616 new_economy_date_fract = 0;
617 } else {
618 /* If the new mode is calendar units, sync the economy year with the calendar year. */
619 new_economy_date = TimerGameEconomy::Date{TimerGameCalendar::date.base()};
620 new_economy_date_fract = TimerGameCalendar::date_fract;
621 }
622
623 /* If you open a savegame as a scenario, there may already be link graphs and/or vehicles. These use economy date. */
625 for (auto v : Vehicle::Iterate()) v->ShiftDates(new_economy_date - TimerGameEconomy::date);
626
627 /* Only change the date after changing cached values above. */
628 TimerGameEconomy::SetDate(new_economy_date, new_economy_date_fract);
629 }
630}
631
636static void ChangeMinutesPerYear(int32_t new_value)
637{
638 /* We don't allow setting Minutes Per Year below default, unless it's to 0 for frozen calendar time. */
639 if (new_value < CalendarTime::DEF_MINUTES_PER_YEAR) {
640 int clamped;
641
642 /* If the new value is 1, we're probably at 0 and trying to increase the value, so we should jump up to default. */
643 if (new_value == 1) {
644 clamped = CalendarTime::DEF_MINUTES_PER_YEAR;
645 } else {
646 clamped = CalendarTime::FROZEN_MINUTES_PER_YEAR;
647 }
648
649 /* Override the setting with the clamped value. */
650 if (_game_mode == GM_MENU) {
652 } else {
654 }
655 }
656
657 /* If the setting value is not the default, force the game to use wallclock timekeeping units.
658 * 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.
659 */
660 if (_game_mode == GM_MENU && (_settings_newgame.economy.minutes_per_calendar_year != CalendarTime::DEF_MINUTES_PER_YEAR)) {
663 }
664}
665
671static bool CanChangeTimetableMode(int32_t &)
672{
674}
675
676/* 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.
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.
@ 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
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
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.
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 int32_t GetDefaultServiceInterval(const IntSettingDesc &sd, VehicleType type)
Checks if the service intervals in the settings are specified as percentages and corrects the default...
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 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.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
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:585
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.
int32_t def
default value given when none is present
StringID str
(translated) string with descriptive text; gui and console
Size related data of the map.
Definition map_func.h:206
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 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 bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static Titem * Get(size_t index)
Returns Titem with given index.
Buses, trucks and trams belong to this class.
Definition roadveh.h:98
All ships have this type.
Definition ship.h:32
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:533
'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.
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:97
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.
@ VEH_ROAD
Road vehicle type.
@ VEH_AIRCRAFT
Aircraft vehicle type.
@ VEH_SHIP
Ship vehicle type.
@ VEH_TRAIN
Train vehicle type.
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:3399
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:1137
int PositionMainToolbar(Window *w)
(Re)position main toolbar window at the screen.
Definition window.cpp:3388
int PositionNetworkChatWindow(Window *w)
(Re)position network chat window at the screen.
Definition window.cpp:3421
void ReInitAllWindows(bool zoom_changed)
Re-initialize all windows.
Definition window.cpp:3333
void CloseWindowByClass(WindowClass cls, int data)
Close all windows of a given class.
Definition window.cpp:1149
int PositionNewsMessage(Window *w)
(Re)position news message window at the screen.
Definition window.cpp:3410
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition window.cpp:3125
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:3217
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:3234
Window functions not directly related to making/drawing windows.
@ WC_BUILD_STATION
Build station; Window numbers:
@ WC_SPRITE_ALIGNER
Sprite aligner (debug); Window numbers:
@ WC_COMPANY_COLOUR
Company colour selection; Window numbers:
@ WC_FOUND_TOWN
Found a town; Window numbers:
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition window_type.h:75
@ WC_SELECT_STATION
Select station (when joining stations); Window numbers:
@ WC_ENGINE_PREVIEW
Engine preview window; Window numbers:
@ WC_CLIENT_LIST
Client list; Window numbers:
@ WC_TOWN_VIEW
Town view; Window numbers:
@ WC_GAME_OPTIONS
Game options window; Window numbers:
@ WC_SMALLMAP
Small map; Window numbers:
@ WC_SAVELOAD
Saveload window; Window numbers:
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers: