OpenTTD Source: src/settings_table.cpp Source File

OpenTTD Source 14.1

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"
19 #include "pathfinder/pathfinder_type.h"
20 #include "linkgraph/linkgraphschedule.h"
21 #include "genworld.h"
22 #include "train.h"
23 #include "news_func.h"
24 #include "window_func.h"
25 #include "company_func.h"
26 #include "timer/timer_game_calendar.h"
27 #if defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA)
28 #define HAS_TRUETYPE_FONT
29 #include "fontcache.h"
30 #endif
31 #include "textbuf_gui.h"
32 #include "rail_gui.h"
33 #include "elrail_func.h"
34 #include "error.h"
35 #include "town.h"
36 #include "video/video_driver.hpp"
37 #include "sound/sound_driver.hpp"
38 #include "music/music_driver.hpp"
39 #include "blitter/factory.hpp"
40 #include "base_media_base.h"
41 #include "ai/ai_config.hpp"
42 #include "ai/ai.hpp"
43 #include "game/game_config.hpp"
44 #include "ship.h"
45 #include "smallmap_gui.h"
46 #include "roadveh.h"
47 #include "roadveh_cmd.h"
48 #include "vehicle_func.h"
49 #include "viewport_func.h"
50 #include "void_map.h"
51 #include "station_func.h"
52 #include "station_base.h"
53
54 #include "table/strings.h"
55 #include "table/settings.h"
56
57 #include "safeguards.h"
58
59 SettingTable _company_settings{ _company_settings_table };
60 SettingTable _currency_settings{ _currency_settings_table };
61 SettingTable _difficulty_settings{ _difficulty_settings_table };
62 SettingTable _multimedia_settings{ _multimedia_settings_table };
63 SettingTable _economy_settings{ _economy_settings_table };
64 SettingTable _game_settings{ _game_settings_table };
65 SettingTable _gui_settings{ _gui_settings_table };
66 SettingTable _linkgraph_settings{ _linkgraph_settings_table };
67 SettingTable _locale_settings{ _locale_settings_table };
68 SettingTable _misc_settings{ _misc_settings_table };
69 SettingTable _network_private_settings{ _network_private_settings_table };
70 SettingTable _network_secrets_settings{ _network_secrets_settings_table };
71 SettingTable _network_settings{ _network_settings_table };
72 SettingTable _news_display_settings{ _news_display_settings_table };
73 SettingTable _old_gameopt_settings{ _old_gameopt_settings_table };
74 SettingTable _pathfinding_settings{ _pathfinding_settings_table };
75 SettingTable _script_settings{ _script_settings_table };
76 SettingTable _window_settings{ _window_settings_table };
77 SettingTable _world_settings{ _world_settings_table };
78 #if defined(_WIN32) && !defined(DEDICATED)
79 SettingTable _win32_settings{ _win32_settings_table };
80 #endif /* _WIN32 */
81
82
83 /* Begin - Callback Functions for the various settings. */
84
86 static StringID SettingTitleWallclock(const IntSettingDesc &sd)
87 {
88 return TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU) ? sd.str + 1 : sd.str;
89 }
90
92 static StringID SettingHelpWallclock(const IntSettingDesc &sd)
93 {
94 return TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU) ? sd.str_help + 1 : sd.str_help;
95 }
96
98 static void SettingsValueVelocityUnit(const IntSettingDesc &, uint first_param, int32_t value)
99 {
100 StringID val;
101 switch (value) {
102 case 0: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_IMPERIAL; break;
103 case 1: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_METRIC; break;
104 case 2: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_SI; break;
105 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;
106 case 4: val = STR_CONFIG_SETTING_LOCALISATION_UNITS_VELOCITY_KNOTS; break;
107 default: NOT_REACHED();
108 }
109 SetDParam(first_param, val);
110 }
111
113 static void SettingsValueAbsolute(const IntSettingDesc &sd, uint first_param, int32_t value)
114 {
115 SetDParam(first_param, sd.str_val + ((value >= 0) ? 1 : 0));
116 SetDParam(first_param + 1, abs(value));
117 }
118
120 static void v_PositionMainToolbar(int32_t)
121 {
122 if (_game_mode != GM_MENU) PositionMainToolbar(nullptr);
123 }
124
126 static void v_PositionStatusbar(int32_t)
127 {
128 if (_game_mode != GM_MENU) {
129 PositionStatusbar(nullptr);
130 PositionNewsMessage(nullptr);
131 PositionNetworkChatWindow(nullptr);
132 }
133 }
134
138 static void RedrawSmallmap(int32_t)
139 {
140 BuildLandLegend();
141 BuildOwnerLegend();
142 SetWindowClassesDirty(WC_SMALLMAP);
143 }
144
146 static void UpdateLinkgraphColours(int32_t)
147 {
148 BuildLinkStatsLegend();
149 MarkWholeScreenDirty();
150 }
151
152 static void StationSpreadChanged(int32_t)
153 {
154 InvalidateWindowData(WC_SELECT_STATION, 0);
155 InvalidateWindowData(WC_BUILD_STATION, 0);
156 }
157
158 static void UpdateConsists(int32_t)
159 {
160 for (Train *t : Train::Iterate()) {
161 /* Update the consist of all trains so the maximum speed is set correctly. */
162 if (t->IsFrontEngine() || t->IsFreeWagon()) t->ConsistChanged(CCF_TRACK);
163 }
164 InvalidateWindowClassesData(WC_BUILD_VEHICLE, 0);
165 }
166
171 static void UpdateAllServiceInterval(int32_t new_value)
172 {
173 bool update_vehicles;
174 VehicleDefaultSettings *vds;
175 if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
176 vds = &_settings_client.company.vehicle;
177 update_vehicles = false;
178 } else {
179 vds = &Company::Get(_current_company)->settings.vehicle;
180 update_vehicles = true;
181 }
182
183 if (new_value != 0) {
184 /* Service intervals are in percents. */
185 vds->servint_trains = DEF_SERVINT_PERCENT;
186 vds->servint_roadveh = DEF_SERVINT_PERCENT;
187 vds->servint_aircraft = DEF_SERVINT_PERCENT;
188 vds->servint_ships = DEF_SERVINT_PERCENT;
189 } else if (TimerGameEconomy::UsingWallclockUnits(_game_mode == GM_MENU)) {
190 /* Service intervals are in minutes. */
191 vds->servint_trains = DEF_SERVINT_MINUTES_TRAINS;
192 vds->servint_roadveh = DEF_SERVINT_MINUTES_ROADVEH;
193 vds->servint_aircraft = DEF_SERVINT_MINUTES_AIRCRAFT;
194 vds->servint_ships = DEF_SERVINT_MINUTES_SHIPS;
195 } else {
196 /* Service intervals are in days. */
197 vds->servint_trains = DEF_SERVINT_DAYS_TRAINS;
198 vds->servint_roadveh = DEF_SERVINT_DAYS_ROADVEH;
199 vds->servint_aircraft = DEF_SERVINT_DAYS_AIRCRAFT;
200 vds->servint_ships = DEF_SERVINT_DAYS_SHIPS;
201 }
202
203 if (update_vehicles) {
204 const Company *c = Company::Get(_current_company);
205 for (Vehicle *v : Vehicle::Iterate()) {
206 if (v->owner == _current_company && v->IsPrimaryVehicle() && !v->ServiceIntervalIsCustom()) {
207 v->SetServiceInterval(CompanyServiceInterval(c, v->type));
208 v->SetServiceIntervalIsPercent(new_value != 0);
209 }
210 }
211 }
212
213 SetWindowClassesDirty(WC_VEHICLE_DETAILS);
214 }
215
216 static bool CanUpdateServiceInterval(VehicleType, int32_t &new_value)
217 {
218 VehicleDefaultSettings *vds;
219 if (_game_mode == GM_MENU || !Company::IsValidID(_current_company)) {
220 vds = &_settings_client.company.vehicle;
221 } else {
222 vds = &Company::Get(_current_company)->settings.vehicle;
223 }
224
225 /* Test if the interval is valid */
226 int32_t interval = GetServiceIntervalClamped(new_value, vds->servint_ispercent);
227 return interval == new_value;
228 }
229
230 static void UpdateServiceInterval(VehicleType type, int32_t new_value)
231 {
232 if (_game_mode != GM_MENU && Company::IsValidID(_current_company)) {
233 for (Vehicle *v : Vehicle::Iterate()) {
234 if (v->owner == _current_company && v->type == type && v->IsPrimaryVehicle() && !v->ServiceIntervalIsCustom()) {
235 v->SetServiceInterval(new_value);
236 }
237 }
238 }
239
240 SetWindowClassesDirty(WC_VEHICLE_DETAILS);
241 }
242
243 static void TrainAccelerationModelChanged(int32_t)
244 {
245 for (Train *t : Train::Iterate()) {
246 if (t->IsFrontEngine()) {
247 t->tcache.cached_max_curve_speed = t->GetCurveSpeedLimit();
248 t->UpdateAcceleration();
249 }
250 }
251
252 /* These windows show acceleration values only when realistic acceleration is on. They must be redrawn after a setting change. */
253 SetWindowClassesDirty(WC_ENGINE_PREVIEW);
254 InvalidateWindowClassesData(WC_BUILD_VEHICLE, 0);
255 SetWindowClassesDirty(WC_VEHICLE_DETAILS);
256 }
257
261 static void TrainSlopeSteepnessChanged(int32_t)
262 {
263 for (Train *t : Train::Iterate()) {
264 if (t->IsFrontEngine()) t->CargoChanged();
265 }
266 }
267
271 static void RoadVehAccelerationModelChanged(int32_t)
272 {
273 if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) {
274 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
275 if (rv->IsFrontEngine()) {
276 rv->CargoChanged();
277 }
278 }
279 }
280
281 /* These windows show acceleration values only when realistic acceleration is on. They must be redrawn after a setting change. */
282 SetWindowClassesDirty(WC_ENGINE_PREVIEW);
283 InvalidateWindowClassesData(WC_BUILD_VEHICLE, 0);
284 SetWindowClassesDirty(WC_VEHICLE_DETAILS);
285 }
286
290 static void RoadVehSlopeSteepnessChanged(int32_t)
291 {
292 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
293 if (rv->IsFrontEngine()) rv->CargoChanged();
294 }
295 }
296
297 static void TownFoundingChanged(int32_t)
298 {
299 if (_game_mode != GM_EDITOR && _settings_game.economy.found_town == TF_FORBIDDEN) {
300 CloseWindowById(WC_FOUND_TOWN, 0);
301 } else {
302 InvalidateWindowData(WC_FOUND_TOWN, 0);
303 }
304 }
305
306 static void ZoomMinMaxChanged(int32_t)
307 {
308 ConstrainAllViewportsZoom();
309 GfxClearSpriteCache();
310 InvalidateWindowClassesData(WC_SPRITE_ALIGNER);
311 if (AdjustGUIZoom(false)) {
312 ReInitAllWindows(true);
313 }
314 }
315
316 static void SpriteZoomMinChanged(int32_t)
317 {
318 GfxClearSpriteCache();
319 /* Force all sprites to redraw at the new chosen zoom level */
320 MarkWholeScreenDirty();
321 }
322
328 static void InvalidateNewGRFChangeWindows(int32_t)
329 {
330 InvalidateWindowClassesData(WC_SAVELOAD);
331 CloseWindowByClass(WC_GAME_OPTIONS);
332 ReInitAllWindows(false);
333 }
334
335 static void InvalidateCompanyLiveryWindow(int32_t)
336 {
337 InvalidateWindowClassesData(WC_COMPANY_COLOUR, -1);
338 ResetVehicleColourMap();
339 }
340
341 static void DifficultyNoiseChange(int32_t)
342 {
343 if (_game_mode == GM_NORMAL) {
344 UpdateAirportsNoise();
345 if (_settings_game.economy.station_noise_level) {
346 InvalidateWindowClassesData(WC_TOWN_VIEW, 0);
347 }
348 }
349 }
350
351 static void MaxNoAIsChange(int32_t)
352 {
353 if (GetGameSettings().difficulty.max_no_competitors != 0 &&
354 AI::GetInfoList()->empty() &&
355 (!_networking || _network_server)) {
356 ShowErrorMessage(STR_WARNING_NO_SUITABLE_AI, INVALID_STRING_ID, WL_CRITICAL);
357 }
358
359 InvalidateWindowClassesData(WC_GAME_OPTIONS, 0);
360 }
361
366 static bool CheckRoadSide(int32_t &)
367 {
368 return _game_mode == GM_MENU || !RoadVehiclesAreBuilt();
369 }
370
378 static size_t ConvertLandscape(const char *value)
379 {
380 /* try with the old values */
381 static std::vector<std::string> _old_landscape_values{"normal", "hilly", "desert", "candy"};
382 return OneOfManySettingDesc::ParseSingleValue(value, strlen(value), _old_landscape_values);
383 }
384
385 static bool CheckFreeformEdges(int32_t &new_value)
386 {
387 if (_game_mode == GM_MENU) return true;
388 if (new_value != 0) {
389 for (Ship *s : Ship::Iterate()) {
390 /* Check if there is a ship on the northern border. */
391 if (TileX(s->tile) == 0 || TileY(s->tile) == 0) {
392 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_EMPTY, INVALID_STRING_ID, WL_ERROR);
393 return false;
394 }
395 }
396 for (const BaseStation *st : BaseStation::Iterate()) {
397 /* Check if there is a non-deleted buoy on the northern border. */
398 if (st->IsInUse() && (TileX(st->xy) == 0 || TileY(st->xy) == 0)) {
399 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_EMPTY, INVALID_STRING_ID, WL_ERROR);
400 return false;
401 }
402 }
403 } else {
404 for (uint i = 0; i < Map::MaxX(); i++) {
405 if (TileHeight(TileXY(i, 1)) != 0) {
406 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
407 return false;
408 }
409 }
410 for (uint i = 1; i < Map::MaxX(); i++) {
411 if (!IsTileType(TileXY(i, Map::MaxY() - 1), MP_WATER) || TileHeight(TileXY(1, Map::MaxY())) != 0) {
412 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
413 return false;
414 }
415 }
416 for (uint i = 0; i < Map::MaxY(); i++) {
417 if (TileHeight(TileXY(1, i)) != 0) {
418 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
419 return false;
420 }
421 }
422 for (uint i = 1; i < Map::MaxY(); i++) {
423 if (!IsTileType(TileXY(Map::MaxX() - 1, i), MP_WATER) || TileHeight(TileXY(Map::MaxX(), i)) != 0) {
424 ShowErrorMessage(STR_CONFIG_SETTING_EDGES_NOT_WATER, INVALID_STRING_ID, WL_ERROR);
425 return false;
426 }
427 }
428 }
429 return true;
430 }
431
432 static void UpdateFreeformEdges(int32_t new_value)
433 {
434 if (_game_mode == GM_MENU) return;
435
436 if (new_value != 0) {
437 for (uint x = 0; x < Map::SizeX(); x++) MakeVoid(TileXY(x, 0));
438 for (uint y = 0; y < Map::SizeY(); y++) MakeVoid(TileXY(0, y));
439 } else {
440 /* Make tiles at the border water again. */
441 for (uint i = 0; i < Map::MaxX(); i++) {
442 SetTileHeight(TileXY(i, 0), 0);
443 SetTileType(TileXY(i, 0), MP_WATER);
444 }
445 for (uint i = 0; i < Map::MaxY(); i++) {
446 SetTileHeight(TileXY(0, i), 0);
447 SetTileType(TileXY(0, i), MP_WATER);
448 }
449 }
450 MarkWholeScreenDirty();
451 }
452
457 static bool CheckDynamicEngines(int32_t &)
458 {
459 if (_game_mode == GM_MENU) return true;
460
461 if (!EngineOverrideManager::ResetToCurrentNewGRFConfig()) {
462 ShowErrorMessage(STR_CONFIG_SETTING_DYNAMIC_ENGINES_EXISTING_VEHICLES, INVALID_STRING_ID, WL_ERROR);
463 return false;
464 }
465
466 return true;
467 }
468
469 static bool CheckMaxHeightLevel(int32_t &new_value)
470 {
471 if (_game_mode == GM_NORMAL) return false;
472 if (_game_mode != GM_EDITOR) return true;
473
474 /* Check if at least one mountain on the map is higher than the new value.
475 * If yes, disallow the change. */
476 for (TileIndex t = 0; t < Map::Size(); t++) {
477 if ((int32_t)TileHeight(t) > new_value) {
478 ShowErrorMessage(STR_CONFIG_SETTING_TOO_HIGH_MOUNTAIN, INVALID_STRING_ID, WL_ERROR);
479 /* Return old, unchanged value */
480 return false;
481 }
482 }
483
484 return true;
485 }
486
487 static void StationCatchmentChanged(int32_t)
488 {
489 Station::RecomputeCatchmentForAll();
490 MarkWholeScreenDirty();
491 }
492
493 static void MaxVehiclesChanged(int32_t)
494 {
495 InvalidateWindowClassesData(WC_BUILD_TOOLBAR);
496 MarkWholeScreenDirty();
497 }
498
499 static void InvalidateShipPathCache(int32_t)
500 {
501 for (Ship *s : Ship::Iterate()) {
502 s->path.clear();
503 }
504 }
505
511 static bool ReplaceAsteriskWithEmptyPassword(std::string &newval)
512 {
513 if (newval.compare("*") == 0) newval.clear();
514 return true;
515 }
516
518 static void UpdateClientConfigValues()
519 {
520 NetworkServerUpdateGameInfo();
521
522 if (_network_server) {
523 NetworkServerSendConfigUpdate();
524 SetWindowClassesDirty(WC_CLIENT_LIST);
525 }
526 }
527
532 static void ChangeTimekeepingUnits(int32_t)
533 {
534 /* If service intervals are in time units (calendar days or real-world minutes), reset them to the correct defaults. */
535 if (!_settings_client.company.vehicle.servint_ispercent) {
536 UpdateAllServiceInterval(0);
537 }
538
539 /* If we are using calendar timekeeping, "minutes per year" must be default. */
540 if (!TimerGameEconomy::UsingWallclockUnits(true)) {
541 _settings_newgame.economy.minutes_per_calendar_year = CalendarTime::DEF_MINUTES_PER_YEAR;
542 }
543
544 InvalidateWindowClassesData(WC_GAME_OPTIONS, 0);
545
546 /* It is possible to change these units in Scenario Editor. We must set the economy date appropriately. */
547 if (_game_mode == GM_EDITOR) {
548 TimerGameEconomy::Date new_economy_date;
549 TimerGameEconomy::DateFract new_economy_date_fract;
550
551 if (TimerGameEconomy::UsingWallclockUnits()) {
552 /* If the new mode is wallclock units, set the economy year back to 1. */
553 new_economy_date = TimerGameEconomy::ConvertYMDToDate(1, 0, 1);
554 new_economy_date_fract = 0;
555 } else {
556 /* If the new mode is calendar units, sync the economy year with the calendar year. */
557 new_economy_date = TimerGameCalendar::date.base();
558 new_economy_date_fract = TimerGameCalendar::date_fract;
559 }
560
561 /* If you open a savegame as a scenario, there may already be link graphs and/or vehicles. These use economy date. */
562 LinkGraphSchedule::instance.ShiftDates(new_economy_date - TimerGameEconomy::date);
563 for (auto v : Vehicle::Iterate()) v->ShiftDates(new_economy_date - TimerGameEconomy::date);
564
565 /* Only change the date after changing cached values above. */
566 TimerGameEconomy::SetDate(new_economy_date, new_economy_date_fract);
567 }
568 }
569
574 static void ChangeMinutesPerYear(int32_t new_value)
575 {
576 /* We don't allow setting Minutes Per Year below default, unless it's to 0 for frozen calendar time. */
577 if (new_value < CalendarTime::DEF_MINUTES_PER_YEAR) {
578 int clamped;
579
580 /* If the new value is 1, we're probably at 0 and trying to increase the value, so we should jump up to default. */
581 if (new_value == 1) {
582 clamped = CalendarTime::DEF_MINUTES_PER_YEAR;
583 } else {
584 clamped = CalendarTime::FROZEN_MINUTES_PER_YEAR;
585 }
586
587 /* Override the setting with the clamped value. */
588 if (_game_mode == GM_MENU) {
589 _settings_newgame.economy.minutes_per_calendar_year = clamped;
590 } else {
591 _settings_game.economy.minutes_per_calendar_year = clamped;
592 }
593 }
594
595 /* If the setting value is not the default, force the game to use wallclock timekeeping units.
596 * 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.
597 */
598 if (_game_mode == GM_MENU && (_settings_newgame.economy.minutes_per_calendar_year != CalendarTime::DEF_MINUTES_PER_YEAR)) {
599 _settings_newgame.economy.timekeeping_units = TKU_WALLCLOCK;
600 InvalidateWindowClassesData(WC_GAME_OPTIONS, 0);
601 }
602 }
603
609 static bool CanChangeTimetableMode(int32_t &)
610 {
611 return !TimerGameEconomy::UsingWallclockUnits();
612 }
613
614 /* End - Callback Functions */
RoadVehicle
Buses, trucks and trams belong to this class.
Definition: roadveh.h:106
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:437
WC_SAVELOAD
@ WC_SAVELOAD
Saveload window; Window numbers:
Definition: window_type.h:144
BuildOwnerLegend
void BuildOwnerLegend()
Completes the array for the owned property legend.
Definition: smallmap_gui.cpp:343
InvalidateWindowData
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:3204
CloseWindowByClass
void CloseWindowByClass(WindowClass cls, int data)
Close all windows of a given class.
Definition: window.cpp:1153
factory.hpp
EngineOverrideManager::ResetToCurrentNewGRFConfig
static bool ResetToCurrentNewGRFConfig()
Tries to reset the engine mapping to match the current NewGRF configuration.
Definition: engine.cpp:549
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
WC_BUILD_TOOLBAR
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition: window_type.h:73
train.h
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
Definition: error_gui.cpp:367
PositionMainToolbar
int PositionMainToolbar(Window *w)
(Re)position main toolbar window at the screen.
Definition: window.cpp:3374
TimerGameCalendar::date_fract
static DateFract date_fract
Fractional part of the day.
Definition: timer_game_calendar.h:35
smallmap_gui.h
CheckDynamicEngines
static bool CheckDynamicEngines(int32_t &)
Changing the setting "allow multiple NewGRF sets" is not allowed if there are vehicles.
Definition: settings_table.cpp:457
Map::MaxX
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:297
TimerGameEconomy::ConvertYMDToDate
static Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
Definition: timer_game_economy.cpp:66
timer_game_calendar.h
WC_COMPANY_COLOUR
@ WC_COMPANY_COLOUR
Company colour selection; Window numbers:
Definition: window_type.h:230
WC_FOUND_TOWN
@ WC_FOUND_TOWN
Found a town; Window numbers:
Definition: window_type.h:429
currency.h
elrail_func.h
TF_FORBIDDEN
@ TF_FORBIDDEN
Forbidden.
Definition: town_type.h:96
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
_network_server
bool _network_server
network-server is active
Definition: network.cpp:66
WC_ENGINE_PREVIEW
@ WC_ENGINE_PREVIEW
Engine preview window; Window numbers:
Definition: window_type.h:595
CloseWindowById
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:1141
WC_CLIENT_LIST
@ WC_CLIENT_LIST
Client list; Window numbers:
Definition: window_type.h:478
LinkGraphSchedule::instance
static LinkGraphSchedule instance
Static instance of LinkGraphSchedule.
Definition: linkgraphschedule.h:52
CanChangeTimetableMode
static bool CanChangeTimetableMode(int32_t &)
Pre-callback check when trying to change the timetable mode.
Definition: settings_table.cpp:609
SetTileHeight
void SetTileHeight(Tile tile, uint height)
Sets the height of a tile.
Definition: tile_map.h:57
ship.h
UpdateAllServiceInterval
static void UpdateAllServiceInterval(int32_t new_value)
Check and update if needed all vehicle service intervals.
Definition: settings_table.cpp:171
void_map.h
SettingsValueVelocityUnit
static void SettingsValueVelocityUnit(const IntSettingDesc &, uint first_param, int32_t value)
Setting values for velocity unit localisation.
Definition: settings_table.cpp:98
CompanySettings::vehicle
VehicleDefaultSettings vehicle
default settings for vehicles
Definition: settings_type.h:612
UpdateLinkgraphColours
static void UpdateLinkgraphColours(int32_t)
Redraw linkgraph links after a colour scheme change.
Definition: settings_table.cpp:146
EconomySettings::timekeeping_units
TimekeepingUnits timekeeping_units
time units to use for the game economy, either calendar or wallclock
Definition: settings_type.h:560
base_media_base.h
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:54
TimerGameEconomy::UsingWallclockUnits
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
Definition: timer_game_economy.cpp:97
town.h
ConvertLandscape
static size_t ConvertLandscape(const char *value)
Conversion callback for _gameopt_settings_game.landscape It converts (or try) between old values and ...
Definition: settings_table.cpp:378
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
WC_BUILD_STATION
@ WC_BUILD_STATION
Build station; Window numbers:
Definition: window_type.h:397
ChangeTimekeepingUnits
static void ChangeTimekeepingUnits(int32_t)
Callback for when the player changes the timekeeping units.
Definition: settings_table.cpp:532
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:240
UpdateClientConfigValues
static void UpdateClientConfigValues()
Update the game info, and send it to the clients when we are running as a server.
Definition: settings_table.cpp:518
RedrawSmallmap
static void RedrawSmallmap(int32_t)
Redraw the smallmap after a colour scheme change.
Definition: settings_table.cpp:138
genworld.h
textbuf_gui.h
EconomySettings::minutes_per_calendar_year
uint16_t minutes_per_calendar_year
minutes per calendar year. Special value 0 means that calendar time is frozen.
Definition: settings_type.h:561
ChangeMinutesPerYear
static void ChangeMinutesPerYear(int32_t new_value)
Callback after the player changes the minutes per year.
Definition: settings_table.cpp:574
ai.hpp
screenshot.h
AdjustGUIZoom
bool AdjustGUIZoom(bool automatic)
Resolve GUI zoom level and adjust GUI to new zoom, if auto-suggestion is requested.
Definition: gfx.cpp:1810
GetServiceIntervalClamped
uint16_t GetServiceIntervalClamped(int interval, bool ispercent)
Clamp the service interval to the correct min/max.
Definition: order_cmd.cpp:1909
PositionStatusbar
int PositionStatusbar(Window *w)
(Re)position statusbar window at the screen.
Definition: window.cpp:3385
RoadVehiclesAreBuilt
bool RoadVehiclesAreBuilt()
Verify whether a road vehicle is available.
Definition: road_cmd.cpp:179
PositionNewsMessage
int PositionNewsMessage(Window *w)
(Re)position news message window at the screen.
Definition: window.cpp:3396
EconomySettings::station_noise_level
bool station_noise_level
build new airports when the town noise level is still within accepted limits
Definition: settings_type.h:556
IntSettingDesc::str_val
StringID str_val
(Translated) first string describing the value.
Definition: settings_internal.h:217
LinkGraphSchedule::ShiftDates
void ShiftDates(TimerGameEconomy::Date interval)
Shift all dates (join dates and edge annotations) of link graphs and link graph jobs by the number of...
Definition: linkgraphschedule.cpp:135
ReInitAllWindows
void ReInitAllWindows(bool zoom_changed)
Re-initialize all windows.
Definition: window.cpp:3320
GfxClearSpriteCache
void GfxClearSpriteCache()
Remove all encoded sprites from the sprite cache without discarding sprite location information.
Definition: spritecache.cpp:1036
Station::RecomputeCatchmentForAll
static void RecomputeCatchmentForAll()
Recomputes catchment of all stations.
Definition: station.cpp:524
IntSettingDesc
Base integer type, including boolean, settings.
Definition: settings_internal.h:148
MP_WATER
@ MP_WATER
Water tile.
Definition: tile_type.h:54
UpdateAirportsNoise
void UpdateAirportsNoise()
Recalculate the noise generated by the airports of each town.
Definition: station_cmd.cpp:2364
MakeVoid
void MakeVoid(Tile t)
Make a nice void tile ;)
Definition: void_map.h:19
station_func.h
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
WC_VEHICLE_DETAILS
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:200
GameSettings::economy
EconomySettings economy
settings to change the economy
Definition: settings_type.h:627
safeguards.h
AI::GetInfoList
static const ScriptInfoList * GetInfoList()
Wrapper function for AIScanner::GetAIInfoList.
Definition: ai_core.cpp:316
music_driver.hpp
Train
'Train' is either a loco or a wagon.
Definition: train.h:89
VehicleDefaultSettings::servint_aircraft
uint16_t servint_aircraft
service interval for aircraft
Definition: settings_type.h:602
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:65
v_PositionMainToolbar
static void v_PositionMainToolbar(int32_t)
Reposition the main toolbar as the setting changed.
Definition: settings_table.cpp:120
VehicleDefaultSettings
Default settings for vehicles.
Definition: settings_type.h:598
EconomySettings::found_town
TownFounding found_town
town founding.
Definition: settings_type.h:555
error.h
linkgraphschedule.h
stdafx.h
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
settings_table.h
viewport_func.h
pathfinder_type.h
sound_driver.hpp
VehicleSettings::roadveh_acceleration_model
uint8_t roadveh_acceleration_model
realistic acceleration for road vehicles
Definition: settings_type.h:518
Map::SizeX
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition: map_func.h:270
InvalidateNewGRFChangeWindows
static void InvalidateNewGRFChangeWindows(int32_t)
Update any possible saveload window and delete any newgrf dialogue as its widget parts might change.
Definition: settings_table.cpp:328
rail_gui.h
IntSettingDesc::str_help
StringID str_help
(Translated) string with help text; gui only.
Definition: settings_internal.h:216
Ship
All ships have this type.
Definition: ship.h:24
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:51
vehicle_func.h
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition: window_type.h:619
WC_SELECT_STATION
@ WC_SELECT_STATION
Select station (when joining stations); Window numbers:
Definition: window_type.h:242
station_base.h
CheckRoadSide
static bool CheckRoadSide(int32_t &)
Check whether the road side may be changed.
Definition: settings_table.cpp:366
Pool::PoolItem<&_vehicle_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
Map::MaxY
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:306
SettingTitleWallclock
static StringID SettingTitleWallclock(const IntSettingDesc &sd)
Switch setting title depending on wallclock setting.
Definition: settings_table.cpp:86
NetworkServerSendConfigUpdate
void NetworkServerSendConfigUpdate()
Send Config Update.
Definition: network_server.cpp:1990
WC_BUILD_VEHICLE
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers:
Definition: window_type.h:383
abs
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:23
Map::Size
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
video_driver.hpp
SetDParam
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
CompanyServiceInterval
int CompanyServiceInterval(const Company *c, VehicleType type)
Get the service interval for the given company and vehicle type.
Definition: company_cmd.cpp:1198
InvalidateWindowClassesData
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:3221
IntSettingDesc::str
StringID str
(translated) string with descriptive text; gui and console
Definition: settings_internal.h:215
SetTileType
void SetTileType(Tile tile, TileType type)
Set the type of a tile.
Definition: tile_map.h:131
BaseStation
Base class for all station-ish types.
Definition: base_station_base.h:64
VehicleDefaultSettings::servint_trains
uint16_t servint_trains
service interval for trains
Definition: settings_type.h:600
company_func.h
WL_ERROR
@ WL_ERROR
Errors (eg. saving/loading failed)
Definition: error.h:26
SpecializedVehicle< Train, Type >::Iterate
static Pool::IterateWrapper< Train > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
Definition: vehicle_base.h:1280
SettingHelpWallclock
static StringID SettingHelpWallclock(const IntSettingDesc &sd)
Switch setting help depending on wallclock setting.
Definition: settings_table.cpp:92
SettingsValueAbsolute
static void SettingsValueAbsolute(const IntSettingDesc &sd, uint first_param, int32_t value)
A negative value has another string (the one after "strval").
Definition: settings_table.cpp:113
network.h
TimerGameEconomy::SetDate
static void SetDate(Date date, DateFract fract)
Set the date.
Definition: timer_game_economy.cpp:81
VehicleDefaultSettings::servint_ships
uint16_t servint_ships
service interval for ships
Definition: settings_type.h:603
VehicleDefaultSettings::servint_ispercent
bool servint_ispercent
service intervals are in percents
Definition: settings_type.h:599
TimerGame< struct Economy >::DateFract
uint16_t DateFract
The fraction of a date we're in, i.e.
Definition: timer_game_common.h:38
window_func.h
v_PositionStatusbar
static void v_PositionStatusbar(int32_t)
Reposition the statusbar as the setting changed.
Definition: settings_table.cpp:126
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1548
TileXY
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:385
TileHeight
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
Definition: tile_map.h:29
ReplaceAsteriskWithEmptyPassword
static bool ReplaceAsteriskWithEmptyPassword(std::string &newval)
Replace a passwords that are a literal asterisk with an empty string.
Definition: settings_table.cpp:511
config.h
fontcache.h
WC_TOWN_VIEW
@ WC_TOWN_VIEW
Town view; Window numbers:
Definition: window_type.h:333
GetGameSettings
GameSettings & GetGameSettings()
Get the settings-object applicable for the current situation: the newgame settings when we're in the ...
Definition: settings_type.h:659
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition: timer_game_calendar.h:34
ClientSettings::company
CompanySettings company
default values for per-company settings
Definition: settings_type.h:637
PositionNetworkChatWindow
int PositionNetworkChatWindow(Window *w)
(Re)position network chat window at the screen.
Definition: window.cpp:3407
CCF_TRACK
@ CCF_TRACK
Valid changes while vehicle is driving, and possibly changing tracks.
Definition: train.h:48
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:626
RoadVehAccelerationModelChanged
static void RoadVehAccelerationModelChanged(int32_t)
This function updates realistic acceleration caches when the setting "Road vehicle acceleration model...
Definition: settings_table.cpp:271
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:328
RoadVehSlopeSteepnessChanged
static void RoadVehSlopeSteepnessChanged(int32_t)
This function updates the road vehicle acceleration cache after a steepness change.
Definition: settings_table.cpp:290
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:427
TrainSlopeSteepnessChanged
static void TrainSlopeSteepnessChanged(int32_t)
This function updates the train acceleration cache after a steepness change.
Definition: settings_table.cpp:261
Company
Definition: company_base.h:129
game_config.hpp
WC_SPRITE_ALIGNER
@ WC_SPRITE_ALIGNER
Sprite aligner (debug); Window numbers:
Definition: window_type.h:681
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3112
NetworkServerUpdateGameInfo
void NetworkServerUpdateGameInfo()
Update the server's NetworkServerGameInfo due to changes in settings.
Definition: network_server.cpp:1998
BuildLinkStatsLegend
void BuildLinkStatsLegend()
Populate legend table for the link stat view.
Definition: smallmap_gui.cpp:216
VehicleDefaultSettings::servint_roadveh
uint16_t servint_roadveh
service interval for road vehicles
Definition: settings_type.h:601
WC_SMALLMAP
@ WC_SMALLMAP
Small map; Window numbers:
Definition: window_type.h:104
roadveh_cmd.h
network_func.h
_settings_newgame
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition: settings.cpp:56
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition: map_func.h:279
OneOfManySettingDesc::ParseSingleValue
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:179
WL_CRITICAL
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:27
BuildLandLegend
void BuildLandLegend()
(Re)build the colour tables for the legends.
Definition: smallmap_gui.cpp:292
ai_config.hpp
news_func.h
roadveh.h
TimerGameEconomy::date
static Date date
Current date in days (day counter).
Definition: timer_game_economy.h:37