OpenTTD Source: src/genworld.cpp Source File

OpenTTD Source 15.0-beta1

genworld.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
10#include "stdafx.h"
11#include "landscape.h"
12#include "company_func.h"
13#include "town_cmd.h"
14#include "signs_cmd.h"
15#include "3rdparty/nlohmann/json.hpp"
16#include "strings_func.h"
17#include "genworld.h"
18#include "gfxinit.h"
19#include "window_func.h"
20#include "network/network.h"
21#include "heightmap.h"
22#include "viewport_func.h"
23#include "timer/timer_game_calendar.h"
24#include "timer/timer_game_tick.h"
25#include "engine_func.h"
26#include "water.h"
27#include "video/video_driver.hpp"
28#include "tilehighlight_func.h"
29#include "saveload/saveload.h"
30#include "void_map.h"
31#include "town.h"
32#include "newgrf.h"
33#include "newgrf_house.h"
34#include "core/random_func.hpp"
35#include "core/backup_type.hpp"
36#include "progress.h"
37#include "error.h"
38#include "game/game.hpp"
39#include "game/game_instance.hpp"
40#include "string_func.h"
41#include "thread.h"
42#include "tgp.h"
43
44#include "safeguards.h"
45
46
47void GenerateClearTile();
48void GenerateIndustries();
49void GenerateObjects();
50void GenerateTrees();
51
52void StartupEconomy();
53void StartupCompanies();
54void StartupDisasters();
55
56void InitializeGame(uint size_x, uint size_y, bool reset_date, bool reset_settings);
57
64 GenWorldInfo _gw;
65
67 bool _generating_world;
68
69 class AbortGenerateWorldSignal { };
70
74 static void CleanupGeneration()
75{
76 _generating_world = false;
77
78 SetMouseCursorBusy(false);
79 SetModalProgress(false);
80 _gw.proc = nullptr;
81 _gw.abortp = nullptr;
82
83 CloseWindowByClass(WC_MODAL_PROGRESS);
84 ShowFirstError();
85 MarkWholeScreenDirty();
86}
87
91 static void _GenerateWorld()
92{
93 /* Make sure everything is done via OWNER_NONE. */
94 Backup<CompanyID> _cur_company(_current_company, OWNER_NONE);
95
96 try {
97 _generating_world = true;
98 if (_network_dedicated) Debug(net, 3, "Generating map, please wait...");
99 /* Set the Random() seed to generation_seed so we produce the same map with the same seed */
100 _random.SetSeed(_settings_game.game_creation.generation_seed);
101 SetGeneratingWorldProgress(GWP_MAP_INIT, 2);
102 SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, HT_NONE, WC_MAIN_WINDOW, 0);
103 ScriptObject::InitializeRandomizers();
104
105 BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP);
106
107 IncreaseGeneratingWorldProgress(GWP_MAP_INIT);
108 /* Must start economy early because of the costs. */
109 StartupEconomy();
110 if (!CheckTownRoadTypes()) {
111 HandleGeneratingWorldAbortion();
112 return;
113 }
114
115 bool landscape_generated = false;
116
117 /* Don't generate landscape items when in the scenario editor. */
118 if (_gw.mode != GWM_EMPTY) {
119 landscape_generated = GenerateLandscape(_gw.mode);
120 }
121
122 if (!landscape_generated) {
123 SetGeneratingWorldProgress(GWP_OBJECT, 1);
124
125 /* Make sure the tiles at the north border are void tiles if needed. */
126 if (_settings_game.construction.freeform_edges) {
127 for (uint x = 0; x < Map::SizeX(); x++) MakeVoid(TileXY(x, 0));
128 for (uint y = 0; y < Map::SizeY(); y++) MakeVoid(TileXY(0, y));
129 }
130
131 /* Make the map the height of the setting */
132 if (_game_mode != GM_MENU) FlatEmptyWorld(_settings_game.game_creation.se_flat_world_height);
133
134 ConvertGroundTilesIntoWaterTiles();
135 IncreaseGeneratingWorldProgress(GWP_OBJECT);
136
137 _settings_game.game_creation.snow_line_height = DEF_SNOWLINE_HEIGHT;
138 } else {
139 GenerateClearTile();
140
141 /* Only generate towns, tree and industries in newgame mode. */
142 if (_game_mode != GM_EDITOR) {
143 if (!GenerateTowns(_settings_game.economy.town_layout)) {
144 HandleGeneratingWorldAbortion();
145 return;
146 }
147 GenerateIndustries();
148 GenerateObjects();
149 GenerateTrees();
150 }
151 }
152
153 /* These are probably pointless when inside the scenario editor. */
154 SetGeneratingWorldProgress(GWP_GAME_INIT, 3);
155 StartupCompanies();
156 IncreaseGeneratingWorldProgress(GWP_GAME_INIT);
157 StartupEngines();
158 IncreaseGeneratingWorldProgress(GWP_GAME_INIT);
159 StartupDisasters();
160 _generating_world = false;
161
162 /* No need to run the tile loop in the scenario editor. */
163 if (_gw.mode != GWM_EMPTY) {
164 uint i;
165
166 SetGeneratingWorldProgress(GWP_RUNTILELOOP, 0x500);
167 for (i = 0; i < 0x500; i++) {
168 RunTileLoop();
169 TimerGameTick::counter++;
170 IncreaseGeneratingWorldProgress(GWP_RUNTILELOOP);
171 }
172
173 if (_game_mode != GM_EDITOR) {
174 Game::StartNew();
175
176 if (Game::GetInstance() != nullptr) {
177 SetGeneratingWorldProgress(GWP_RUNSCRIPT, 2500);
178 _generating_world = true;
179 for (i = 0; i < 2500; i++) {
180 Game::GameLoop();
181 IncreaseGeneratingWorldProgress(GWP_RUNSCRIPT);
182 if (Game::GetInstance()->IsSleeping()) break;
183 }
184 _generating_world = false;
185 }
186 }
187 }
188
189 BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP);
190
191 ResetObjectToPlace();
192 _cur_company.Trash();
193 _current_company = _local_company = _gw.lc;
194 /* Show all vital windows again, because we have hidden them. */
195 if (_game_mode != GM_MENU) ShowVitalWindows();
196
197 SetGeneratingWorldProgress(GWP_GAME_START, 1);
198 /* Call any callback */
199 if (_gw.proc != nullptr) _gw.proc();
200 IncreaseGeneratingWorldProgress(GWP_GAME_START);
201
202 CleanupGeneration();
203
204 ShowNewGRFError();
205
206 if (_network_dedicated) Debug(net, 3, "Map generated, starting game");
207 Debug(desync, 1, "new_map: {:08x}", _settings_game.game_creation.generation_seed);
208
209 if (_debug_desync_level > 0) {
210 std::string name = fmt::format("dmp_cmds_{:08x}_{:08x}.sav", _settings_game.game_creation.generation_seed, TimerGameEconomy::date);
211 SaveOrLoad(name, SLO_SAVE, DFT_GAME_FILE, AUTOSAVE_DIR, false);
212 }
213 } catch (AbortGenerateWorldSignal&) {
214 CleanupGeneration();
215
216 BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP, true);
217 if (_cur_company.IsValid()) _cur_company.Restore();
218
219 if (_network_dedicated) {
220 /* Exit the game to prevent a return to main menu. */
221 Debug(net, 0, "Generating map failed; closing server");
222 _exit_game = true;
223 } else {
224 SwitchToMode(_switch_mode);
225 }
226 }
227}
228
234 void GenerateWorldSetCallback(GWDoneProc *proc)
235{
236 _gw.proc = proc;
237}
238
244 void GenerateWorldSetAbortCallback(GWAbortProc *proc)
245{
246 _gw.abortp = proc;
247}
248
252 void AbortGeneratingWorld()
253{
254 _gw.abort = true;
255}
256
261 bool IsGeneratingWorldAborted()
262{
263 return _gw.abort || _exit_game;
264}
265
269 void HandleGeneratingWorldAbortion()
270{
271 /* Clean up - in SE create an empty map, otherwise, go to intro menu */
272 _switch_mode = (_game_mode == GM_EDITOR) ? SM_EDITOR : SM_MENU;
273
274 if (_gw.abortp != nullptr) _gw.abortp();
275
276 throw AbortGenerateWorldSignal();
277}
278
286 void GenerateWorld(GenWorldMode mode, uint size_x, uint size_y, bool reset_settings)
287{
288 if (HasModalProgress()) return;
289 _gw.mode = mode;
290 _gw.size_x = size_x;
291 _gw.size_y = size_y;
292 SetModalProgress(true);
293 _gw.abort = false;
294 _gw.abortp = nullptr;
295 _gw.lc = _local_company;
296
297 /* This disables some commands and stuff */
298 SetLocalCompany(COMPANY_SPECTATOR);
299
300 InitializeGame(_gw.size_x, _gw.size_y, true, reset_settings);
301 PrepareGenerateWorldProgress();
302
303 if (_settings_game.construction.map_height_limit == 0) {
304 uint estimated_height = 0;
305
306 if (_gw.mode == GWM_EMPTY && _game_mode != GM_MENU) {
307 estimated_height = _settings_game.game_creation.se_flat_world_height;
308 } else if (_gw.mode == GWM_HEIGHTMAP) {
309 estimated_height = _settings_game.game_creation.heightmap_height;
310 } else if (_settings_game.game_creation.land_generator == LG_TERRAGENESIS) {
311 estimated_height = GetEstimationTGPMapHeight();
312 } else {
313 estimated_height = 0;
314 }
315
316 _settings_game.construction.map_height_limit = std::max(MAP_HEIGHT_LIMIT_AUTO_MINIMUM, std::min(MAX_MAP_HEIGHT_LIMIT, estimated_height + MAP_HEIGHT_LIMIT_AUTO_CEILING_ROOM));
317 }
318
319 if (_settings_game.game_creation.generation_seed == GENERATE_NEW_SEED) _settings_game.game_creation.generation_seed = InteractiveRandom();
320
321 /* Load the right landscape stuff, and the NewGRFs! */
322 GfxLoadSprites();
323 InitializeBuildingCounts();
324 LoadStringWidthTable();
325
326 /* Re-init the windowing system */
327 ResetWindowSystem();
328
329 /* Create toolbars */
330 SetupColoursAndInitialWindow();
331 SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, HT_NONE, WC_MAIN_WINDOW, 0);
332
333 UnshowCriticalError();
334 CloseAllNonVitalWindows();
335 HideVitalWindows();
336
337 ShowGenerateWorldProgress();
338
339 /* Centre the view on the map */
340 ScrollMainWindowToTile(TileXY(Map::SizeX() / 2, Map::SizeY() / 2), true);
341
342 _GenerateWorld();
343}
344
346 struct ExternalTownData {
347 TownID town_id;
348 std::string name;
349 uint population;
350 bool is_city;
351 float x_proportion;
352 float y_proportion;
353};
354
361 static bool TryFoundTownNearby(TileIndex tile, void *user_data)
362{
363 ExternalTownData &town = *static_cast<ExternalTownData *>(user_data);
364 std::tuple<CommandCost, Money, TownID> result = Command<CMD_FOUND_TOWN>::Do(DC_EXEC, tile, TSZ_SMALL, town.is_city, _settings_game.economy.town_layout, false, 0, town.name);
365
366 TownID id = std::get<TownID>(result);
367
368 /* Check if the command failed. */
369 if (id == INVALID_TOWN) return false;
370
371 /* The command succeeded, send the ID back through user_data. */
372 town.town_id = id;
373 return true;
374}
375
379 void LoadTownData()
380{
381 /* Load the JSON file as a string initially. We'll parse it soon. */
382 size_t filesize;
383 auto f = FioFOpenFile(_file_to_saveload.name, "rb", HEIGHTMAP_DIR, &filesize);
384
385 if (!f.has_value()) {
386 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_JSON_FORMATTED_INCORRECTLY, WL_ERROR);
387 return;
388 }
389
390 std::string text(filesize, '\0');
391 size_t len = fread(text.data(), filesize, 1, *f);
392 f.reset();
393 if (len != 1) {
394 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_JSON_FORMATTED_INCORRECTLY, WL_ERROR);
395 return;
396 }
397
398 /* Now parse the JSON. */
399 nlohmann::json town_data;
400 try {
401 town_data = nlohmann::json::parse(text);
402 } catch (nlohmann::json::exception &) {
403 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_JSON_FORMATTED_INCORRECTLY, WL_ERROR);
404 return;
405 }
406
407 /* Check for JSON formatting errors with the array of towns. */
408 if (!town_data.is_array()) {
409 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_JSON_FORMATTED_INCORRECTLY, WL_ERROR);
410 return;
411 }
412
413 std::vector<std::pair<Town *, uint> > towns;
414 uint failed_towns = 0;
415
416 /* Iterate through towns and attempt to found them. */
417 for (auto &feature : town_data) {
418 ExternalTownData town;
419
420 /* Ensure JSON is formatted properly. */
421 if (!feature.is_object()) {
422 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_JSON_FORMATTED_INCORRECTLY, WL_ERROR);
423 return;
424 }
425
426 /* Check to ensure all fields exist and are of the correct type.
427 * If the town name is formatted wrong, all we can do is give a general warning. */
428 if (!feature.contains("name") || !feature.at("name").is_string()) {
429 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_JSON_FORMATTED_INCORRECTLY, WL_ERROR);
430 return;
431 }
432
433 /* If other fields are formatted wrong, we can actually inform the player which town is the problem. */
434 if (!feature.contains("population") || !feature.at("population").is_number() ||
435 !feature.contains("city") || !feature.at("city").is_boolean() ||
436 !feature.contains("x") || !feature.at("x").is_number() ||
437 !feature.contains("y") || !feature.at("y").is_number()) {
438 feature.at("name").get_to(town.name);
439 SetDParamStr(0, town.name);
440 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_TOWN_FORMATTED_INCORRECTLY, WL_ERROR);
441 return;
442 }
443
444 /* Set town properties. */
445 feature.at("name").get_to(town.name);
446 feature.at("population").get_to(town.population);
447 feature.at("city").get_to(town.is_city);
448
449 /* Set town coordinates. */
450 feature.at("x").get_to(town.x_proportion);
451 feature.at("y").get_to(town.y_proportion);
452
453 /* Check for improper coordinates and warn the player. */
454 if (town.x_proportion <= 0.0f || town.y_proportion <= 0.0f || town.x_proportion >= 1.0f || town.y_proportion >= 1.0f) {
455 SetDParamStr(0, town.name);
456 ShowErrorMessage(STR_TOWN_DATA_ERROR_LOAD_FAILED, STR_TOWN_DATA_ERROR_BAD_COORDINATE, WL_ERROR);
457 return;
458 }
459
460 /* Find the target tile for the town. */
461 TileIndex tile;
462 switch (_settings_game.game_creation.heightmap_rotation) {
463 case HM_CLOCKWISE:
464 /* Tile coordinates align with what we expect. */
465 tile = TileXY(town.x_proportion * Map::MaxX(), town.y_proportion * Map::MaxY());
466 break;
467 case HM_COUNTER_CLOCKWISE:
468 /* Tile coordinates are rotated and must be adjusted. */
469 tile = TileXY((1 - town.y_proportion * Map::MaxX()), town.x_proportion * Map::MaxY());
470 break;
471 default: NOT_REACHED();
472 }
473
474 /* Try founding on the target tile, and if that doesn't work, find the nearest suitable tile up to 16 tiles away.
475 * The target might be on water, blocked somehow, or on a steep slope that can't be terraformed by the founding command. */
476 TileIndex search_tile = tile;
477 bool success = CircularTileSearch(&search_tile, 16, 0, 0, TryFoundTownNearby, &town);
478
479 /* If we still fail to found the town, we'll create a sign at the intended location and tell the player how many towns we failed to create in an error message.
480 * This allows the player to diagnose a heightmap misalignment, if towns end up in the sea, or place towns manually, if in rough terrain. */
481 if (!success) {
482 Command<CMD_PLACE_SIGN>::Post(tile, town.name);
483 failed_towns++;
484 continue;
485 }
486
487 towns.emplace_back(std::make_pair(Town::Get(town.town_id), town.population));
488 }
489
490 /* If we couldn't found a town (or multiple), display a message to the player with the number of failed towns. */
491 if (failed_towns > 0) {
492 SetDParam(0, failed_towns);
493 ShowErrorMessage(STR_TOWN_DATA_ERROR_FAILED_TO_FOUND_TOWN, INVALID_STRING_ID, WL_WARNING);
494 }
495
496 /* Now that we've created the towns, let's grow them to their target populations. */
497 for (const auto &item : towns) {
498 Town *t = item.first;
499 uint population = item.second;
500
501 /* Grid towns can grow almost forever, but the town growth algorithm gets less and less efficient as it wanders roads randomly,
502 * so we set an arbitrary limit. With a flat map and a 3x3 grid layout this results in about 4900 houses, or 2800 houses with "Better roads." */
503 int try_limit = 1000;
504
505 /* If a town repeatedly fails to grow, continuing to try only wastes time. */
506 int fail_limit = 10;
507
508 /* Grow by a constant number of houses each time, instead of growth based on current town size.
509 * We want our try limit to apply in a predictable way, no matter the road layout and other geography. */
510 const int HOUSES_TO_GROW = 10;
511
512 do {
513 uint before = t->cache.num_houses;
514 Command<CMD_EXPAND_TOWN>::Post(t->index, HOUSES_TO_GROW);
515 if (t->cache.num_houses <= before) fail_limit--;
516 } while (fail_limit > 0 && try_limit-- > 0 && t->cache.population < population);
517 }
518}
backup_type.hpp
Class for backupping variables and making sure they are restored later.
AbortGenerateWorldSignal
Definition genworld.cpp:69
Game::StartNew
static void StartNew()
Start up a new GameScript.
Definition game_core.cpp:72
Game::GetInstance
static class GameInstance * GetInstance()
Get the current active instance.
Definition game.hpp:101
Game::GameLoop
static void GameLoop()
Called every game-tick to let Game do something.
Definition game_core.cpp:31
TimerGameEconomy::date
static Date date
Current date in days (day counter).
Definition timer_game_economy.h:38
TimerGameTick::counter
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Definition timer_game_tick.h:60
DC_EXEC
@ DC_EXEC
execute the given command
Definition command_type.h:376
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition company_cmd.cpp:52
SetLocalCompany
void SetLocalCompany(CompanyID new_company)
Sets the local company and updates the settings that are set on a per-company basis to reflect the co...
Definition company_cmd.cpp:117
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:53
company_func.h
Functions related to companies.
COMPANY_SPECTATOR
@ COMPANY_SPECTATOR
The client is spectating.
Definition company_type.h:35
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition company_type.h:25
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition debug.h:37
StartupEngines
void StartupEngines()
Start/initialise all our engines.
Definition engine.cpp:799
engine_func.h
Functions related to engines.
error.h
Functions related to errors.
UnshowCriticalError
void UnshowCriticalError()
Unshow the critical error.
Definition error_gui.cpp:349
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
Definition error_gui.cpp:367
ShowFirstError
void ShowFirstError()
Show the first error of the queue.
Definition error_gui.cpp:335
WL_WARNING
@ WL_WARNING
Other information.
Definition error.h:25
WL_ERROR
@ WL_ERROR
Errors (eg. saving/loading failed)
Definition error.h:26
FioFOpenFile
std::optional< FileHandle > FioFOpenFile(const std::string &filename, const char *mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
Definition fileio.cpp:242
SLO_SAVE
@ SLO_SAVE
File is being saved.
Definition fileio_type.h:56
DFT_GAME_FILE
@ DFT_GAME_FILE
Save game or scenario file.
Definition fileio_type.h:32
HEIGHTMAP_DIR
@ HEIGHTMAP_DIR
Subdirectory of scenario for heightmaps.
Definition fileio_type.h:120
AUTOSAVE_DIR
@ AUTOSAVE_DIR
Subdirectory of save for autosaves.
Definition fileio_type.h:118
game.hpp
Base functions for all Games.
game_instance.hpp
The GameInstance tracks games.
_generating_world
bool _generating_world
Whether we are generating the map or not.
Definition genworld.cpp:67
GenerateWorldSetCallback
void GenerateWorldSetCallback(GWDoneProc *proc)
Set here the function, if any, that you want to be called when landscape generation is done.
Definition genworld.cpp:234
GenerateWorldSetAbortCallback
void GenerateWorldSetAbortCallback(GWAbortProc *proc)
Set here the function, if any, that you want to be called when landscape generation is aborted.
Definition genworld.cpp:244
HandleGeneratingWorldAbortion
void HandleGeneratingWorldAbortion()
Really handle the abortion, i.e.
Definition genworld.cpp:269
_gw
GenWorldInfo _gw
Please only use this variable in genworld.h and genworld.cpp and nowhere else.
Definition genworld.cpp:64
GenerateTrees
void GenerateTrees()
Place new trees.
Definition tree_cmd.cpp:354
_GenerateWorld
static void _GenerateWorld()
The internal, real, generate function.
Definition genworld.cpp:91
TryFoundTownNearby
static bool TryFoundTownNearby(TileIndex tile, void *user_data)
Helper for CircularTileSearch to found a town on or near a given tile.
Definition genworld.cpp:361
GenerateIndustries
void GenerateIndustries()
This function will create random industries during game creation.
Definition industry_cmd.cpp:2445
CleanupGeneration
static void CleanupGeneration()
Generation is done; show windows again and delete the progress window.
Definition genworld.cpp:74
GenerateWorld
void GenerateWorld(GenWorldMode mode, uint size_x, uint size_y, bool reset_settings)
Generate a world.
Definition genworld.cpp:286
AbortGeneratingWorld
void AbortGeneratingWorld()
Initializes the abortion process.
Definition genworld.cpp:252
IsGeneratingWorldAborted
bool IsGeneratingWorldAborted()
Is the generation being aborted?
Definition genworld.cpp:261
LoadTownData
void LoadTownData()
Load town data from _file_to_saveload, place towns at the appropriate locations, and expand them to t...
Definition genworld.cpp:379
StartupCompanies
void StartupCompanies()
Start of a new game.
Definition company_cmd.cpp:659
genworld.h
Functions related to world/map generation.
GWAbortProc
void GWAbortProc()
Called when genworld is aborted.
Definition genworld.h:55
IncreaseGeneratingWorldProgress
void IncreaseGeneratingWorldProgress(GenWorldProgress cls)
Increases the current stage of the world generation with one.
Definition genworld_gui.cpp:1547
MAP_HEIGHT_LIMIT_AUTO_MINIMUM
static const uint MAP_HEIGHT_LIMIT_AUTO_MINIMUM
When map height limit is auto, make this the lowest possible map height limit.
Definition genworld.h:51
ShowGenerateWorldProgress
void ShowGenerateWorldProgress()
Show the window where a user can follow the process of the map generation.
Definition genworld_gui.cpp:1465
GenWorldMode
GenWorldMode
Modes for GenerateWorld.
Definition genworld.h:27
GWM_HEIGHTMAP
@ GWM_HEIGHTMAP
Generate a newgame from a heightmap.
Definition genworld.h:31
GWM_EMPTY
@ GWM_EMPTY
Generate an empty map (sea-level)
Definition genworld.h:29
GWP_OBJECT
@ GWP_OBJECT
Generate objects (radio tower, light houses)
Definition genworld.h:76
GWP_MAP_INIT
@ GWP_MAP_INIT
Initialize/allocate the map, start economy.
Definition genworld.h:70
GWP_RUNSCRIPT
@ GWP_RUNSCRIPT
Runs the game script at most 2500 times, or when ever the script sleeps.
Definition genworld.h:80
GWP_GAME_START
@ GWP_GAME_START
Really prepare to start the game.
Definition genworld.h:81
GWP_GAME_INIT
@ GWP_GAME_INIT
Initialize the game.
Definition genworld.h:78
GWP_RUNTILELOOP
@ GWP_RUNTILELOOP
Runs the tile loop 1280 times to make snow etc.
Definition genworld.h:79
GWDoneProc
void GWDoneProc()
Procedure called when the genworld process finishes.
Definition genworld.h:54
MAP_HEIGHT_LIMIT_AUTO_CEILING_ROOM
static const uint MAP_HEIGHT_LIMIT_AUTO_CEILING_ROOM
When map height limit is auto, the map height limit will be the higest peak plus this value.
Definition genworld.h:52
GENERATE_NEW_SEED
static const uint32_t GENERATE_NEW_SEED
Create a new random seed.
Definition genworld.h:24
SetGeneratingWorldProgress
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
Definition genworld_gui.cpp:1533
PrepareGenerateWorldProgress
void PrepareGenerateWorldProgress()
Initializes the progress counters to the starting point.
Definition genworld_gui.cpp:1453
LG_TERRAGENESIS
@ LG_TERRAGENESIS
TerraGenesis Perlin landscape generator.
Definition genworld.h:21
SetMouseCursorBusy
void SetMouseCursorBusy(bool busy)
Set or unset the ZZZ cursor.
Definition gfx.cpp:1670
LoadStringWidthTable
void LoadStringWidthTable(bool monospace)
Initialize _stringwidth_table cache.
Definition gfx.cpp:1210
_switch_mode
SwitchMode _switch_mode
The next mainloop command.
Definition gfx.cpp:49
GfxLoadSprites
void GfxLoadSprites()
Initialise and load all the sprites.
Definition gfxinit.cpp:323
gfxinit.h
Functions related to the graphics initialization.
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1529
FlatEmptyWorld
void FlatEmptyWorld(uint8_t tile_height)
Make an empty world where all tiles are of height 'tile_height'.
Definition heightmap.cpp:521
heightmap.h
Functions related to creating heightmaps from files.
HM_CLOCKWISE
@ HM_CLOCKWISE
Rotate the map clockwise 45 degrees.
Definition heightmap.h:21
HM_COUNTER_CLOCKWISE
@ HM_COUNTER_CLOCKWISE
Rotate the map counter clockwise 45 degrees.
Definition heightmap.h:20
RunTileLoop
void RunTileLoop()
Gradually iterate over all tiles on the map, calling their TileLoopProcs once every TILE_UPDATE_FREQU...
Definition landscape.cpp:769
GenerateLandscape
bool GenerateLandscape(uint8_t mode)
Definition landscape.cpp:1551
landscape.h
Functions related to OTTD's landscape.
ShowVitalWindows
void ShowVitalWindows()
Show the vital in-game windows.
Definition main_gui.cpp:575
SetupColoursAndInitialWindow
void SetupColoursAndInitialWindow()
Initialise the default colours (remaps and the likes), and load the main windows.
Definition main_gui.cpp:546
CircularTileSearch
bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
Function performing a search around a center tile and going outward, thus in circle.
Definition map.cpp:247
TileXY
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition map_func.h:373
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition network.cpp:68
network.h
Basic functions/variables used all over the place.
newgrf.h
Base for the NewGRF implementation.
ShowNewGRFError
void ShowNewGRFError()
Show the first NewGRF error we can find.
Definition newgrf_gui.cpp:45
InitializeBuildingCounts
void InitializeBuildingCounts()
Initialise global building counts and all town building counts.
Definition newgrf_house.cpp:163
newgrf_house.h
Functions related to NewGRF houses.
PSM_ENTER_GAMELOOP
@ PSM_ENTER_GAMELOOP
Enter the gameloop, changes will be permanent.
Definition newgrf_storage.h:21
PSM_LEAVE_GAMELOOP
@ PSM_LEAVE_GAMELOOP
Leave the gameloop, changes will be temporary.
Definition newgrf_storage.h:22
SM_MENU
@ SM_MENU
Switch to game intro menu.
Definition openttd.h:33
SM_EDITOR
@ SM_EDITOR
Switch to scenario editor.
Definition openttd.h:31
SetModalProgress
void SetModalProgress(bool state)
Set the modal progress state.
Definition progress.cpp:22
progress.h
Functions related to modal progress.
HasModalProgress
bool HasModalProgress()
Check if we are currently in a modal progress state.
Definition progress.h:17
_random
Randomizer _random
Random used in the game state calculations.
Definition random_func.cpp:37
random_func.hpp
Pseudo random number generator.
safeguards.h
A number of safeguards to prevent using unsafe methods.
SaveOrLoad
SaveOrLoadResult SaveOrLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, Subdirectory sb, bool threaded)
Main Save or Load function where the high-level saveload functions are handled.
Definition saveload.cpp:3128
_file_to_saveload
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
Definition saveload.cpp:60
saveload.h
Functions/types related to saving and loading games.
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:57
signs_cmd.h
Command definitions related to signs.
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
string_func.h
Functions related to low-level strings.
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
SetDParamStr
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition strings.cpp:371
strings_func.h
Functions related to OTTD's strings.
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
Backup
Class to backup a specific variable and restore it later.
Definition backup_type.hpp:21
Backup::IsValid
bool IsValid() const
Checks whether the variable was already restored.
Definition backup_type.hpp:61
Backup::Trash
void Trash()
Trash the backup.
Definition backup_type.hpp:101
Backup::Restore
void Restore()
Restore the variable.
Definition backup_type.hpp:110
BasePersistentStorageArray::SwitchMode
static void SwitchMode(PersistentStorageMode mode, bool ignore_prev_mode=false)
Clear temporary changes made since the last call to SwitchMode, and set whether subsequent changes sh...
Definition newgrf_storage.cpp:54
CommandHelper
Definition command_func.h:83
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition settings_type.h:395
ConstructionSettings::map_height_limit
uint8_t map_height_limit
the maximum allowed heightlevel
Definition settings_type.h:382
EconomySettings::town_layout
TownLayout town_layout
select town layout,
Definition settings_type.h:528
ExternalTownData
Town data imported from JSON files and used to place towns.
Definition genworld.cpp:346
ExternalTownData::name
std::string name
The name of the town.
Definition genworld.cpp:348
ExternalTownData::is_city
bool is_city
Should it be created as a city in OpenTTD? If input is blank, defaults to false.
Definition genworld.cpp:350
ExternalTownData::population
uint population
The target population of the town when created in OpenTTD. If input is blank, defaults to 0.
Definition genworld.cpp:349
ExternalTownData::x_proportion
float x_proportion
The X coordinate of the town, as a proportion 0..1 of the maximum X coordinate.
Definition genworld.cpp:351
ExternalTownData::town_id
TownID town_id
The TownID of the town in OpenTTD. Not imported, but set during the founding proceess and stored here...
Definition genworld.cpp:347
ExternalTownData::y_proportion
float y_proportion
The Y coordinate of the town, as a proportion 0..1 of the maximum Y coordinate.
Definition genworld.cpp:352
FileToSaveLoad::name
std::string name
Name of the file.
Definition saveload.h:414
GameCreationSettings::snow_line_height
uint8_t snow_line_height
the configured snow line height (deduced from "snow_coverage")
Definition settings_type.h:359
GameCreationSettings::land_generator
uint8_t land_generator
the landscape generator
Definition settings_type.h:357
GameCreationSettings::se_flat_world_height
uint8_t se_flat_world_height
land height a flat world gets in SE
Definition settings_type.h:366
GameCreationSettings::heightmap_rotation
uint8_t heightmap_rotation
rotation director for the heightmap
Definition settings_type.h:365
GameCreationSettings::generation_seed
uint32_t generation_seed
noise seed for world generation
Definition settings_type.h:352
GameCreationSettings::heightmap_height
uint8_t heightmap_height
highest mountain for heightmap (towards what it scales)
Definition settings_type.h:362
GameSettings::economy
EconomySettings economy
settings to change the economy
Definition settings_type.h:602
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition settings_type.h:594
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition settings_type.h:593
GenWorldInfo
Properties of current genworld process.
Definition genworld.h:58
GenWorldInfo::proc
GWDoneProc * proc
Proc that is called when done (can be nullptr)
Definition genworld.h:64
GenWorldInfo::lc
CompanyID lc
The local_company before generating.
Definition genworld.h:61
GenWorldInfo::size_x
uint size_x
X-size of the map.
Definition genworld.h:62
GenWorldInfo::size_y
uint size_y
Y-size of the map.
Definition genworld.h:63
GenWorldInfo::abort
bool abort
Whether to abort the thread ASAP.
Definition genworld.h:59
GenWorldInfo::abortp
GWAbortProc * abortp
Proc that is called when aborting (can be nullptr)
Definition genworld.h:65
GenWorldInfo::mode
GenWorldMode mode
What mode are we making a world in.
Definition genworld.h:60
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition map_func.h:279
Map::SizeX
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition map_func.h:270
Map::MaxY
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition map_func.h:306
Map::MaxX
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition map_func.h:297
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:238
Pool::PoolItem<&_town_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:339
Randomizer::SetSeed
void SetSeed(uint32_t seed)
(Re)set the state of the random number generator.
Definition random_func.cpp:56
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
TownCache::population
uint32_t population
Current population of people.
Definition town.h:44
TownCache::num_houses
uint32_t num_houses
Amount of houses.
Definition town.h:43
Town
Town data structure.
Definition town.h:54
Town::cache
TownCache cache
Container for all cacheable data.
Definition town.h:57
GetEstimationTGPMapHeight
uint GetEstimationTGPMapHeight()
Get an overestimation of the highest peak TGP wants to generate.
Definition tgp.cpp:250
tgp.h
Functions for the Perlin noise enhanced map generator.
thread.h
Base of all threads.
DEF_SNOWLINE_HEIGHT
static const uint DEF_SNOWLINE_HEIGHT
Default snowline height.
Definition tile_type.h:33
MAX_MAP_HEIGHT_LIMIT
static const uint MAX_MAP_HEIGHT_LIMIT
Upper bound of maximum allowed heightlevel (in the construction settings)
Definition tile_type.h:30
tilehighlight_func.h
Functions related to tile highlights.
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition viewport.cpp:3498
SetObjectToPlace
void SetObjectToPlace(CursorID icon, PaletteID pal, HighLightStyle mode, WindowClass window_class, WindowNumber window_num)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
Definition viewport.cpp:3450
HT_NONE
@ HT_NONE
default
Definition tilehighlight_type.h:20
timer_game_calendar.h
Definition of the game-calendar-timer.
timer_game_tick.h
Definition of the tick-based game-timer.
town.h
Base of the town class.
CheckTownRoadTypes
bool CheckTownRoadTypes()
Check if towns are able to build road.
Definition town_cmd.cpp:1009
GenerateTowns
bool GenerateTowns(TownLayout layout)
Generate a number of towns with a given layout.
Definition town_cmd.cpp:2413
town_cmd.h
Command definitions related to towns.
TSZ_SMALL
@ TSZ_SMALL
Small town.
Definition town_type.h:20
video_driver.hpp
Base of all video drivers.
ScrollMainWindowToTile
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition viewport.cpp:2515
viewport_func.h
Functions related to (drawing on) viewports.
void_map.h
Map accessors for void tiles.
MakeVoid
void MakeVoid(Tile t)
Make a nice void tile ;)
Definition void_map.h:19
water.h
Functions related to water (management)
CloseWindowByClass
void CloseWindowByClass(WindowClass cls, int data)
Close all windows of a given class.
Definition window.cpp:1152
ResetWindowSystem
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition window.cpp:1818
HideVitalWindows
void HideVitalWindows()
Close all always on-top windows to get an empty screen.
Definition window.cpp:3318
CloseAllNonVitalWindows
void CloseAllNonVitalWindows()
It is possible that a stickied window gets to a position where the 'close' button is outside the gami...
Definition window.cpp:3280
window_func.h
Window functions not directly related to making/drawing windows.
WC_MAIN_WINDOW
@ WC_MAIN_WINDOW
Main window; Window numbers:
Definition window_type.h:51
WC_MODAL_PROGRESS
@ WC_MODAL_PROGRESS
Progress report of landscape generation; Window numbers:
Definition window_type.h:469