OpenTTD Source: src/genworld.cpp Source File

OpenTTD Source 13.2.1

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 "genworld.h"
14 #include "gfxinit.h"
15 #include "window_func.h"
16 #include "network/network.h"
17 #include "heightmap.h"
18 #include "viewport_func.h"
19 #include "date_func.h"
20 #include "engine_func.h"
21 #include "water.h"
22 #include "video/video_driver.hpp"
23 #include "tilehighlight_func.h"
24 #include "saveload/saveload.h"
25 #include "void_map.h"
26 #include "town.h"
27 #include "newgrf.h"
28 #include "core/random_func.hpp"
29 #include "core/backup_type.hpp"
30 #include "progress.h"
31 #include "error.h"
32 #include "game/game.hpp"
33 #include "game/game_instance.hpp"
34 #include "string_func.h"
35 #include "thread.h"
36 #include "tgp.h"
37
38 #include "safeguards.h"
39
40
41 void GenerateClearTile();
42 void GenerateIndustries();
43 void GenerateObjects();
44 void GenerateTrees();
45
46 void StartupEconomy();
47 void StartupCompanies();
48 void StartupDisasters();
49
50 void InitializeGame(uint size_x, uint size_y, bool reset_date, bool reset_settings);
51
58 GenWorldInfo _gw;
59
61 bool _generating_world;
62
63 class AbortGenerateWorldSignal { };
64
68 static void CleanupGeneration()
69 {
70 _generating_world = false;
71
72 SetMouseCursorBusy(false);
73 /* Show all vital windows again, because we have hidden them */
74 if (_game_mode != GM_MENU) ShowVitalWindows();
75 SetModalProgress(false);
76 _gw.proc = nullptr;
77 _gw.abortp = nullptr;
78
79 CloseWindowByClass(WC_MODAL_PROGRESS);
80 ShowFirstError();
81 MarkWholeScreenDirty();
82 }
83
87 static void _GenerateWorld()
88 {
89 /* Make sure everything is done via OWNER_NONE. */
90 Backup<CompanyID> _cur_company(_current_company, OWNER_NONE, FILE_LINE);
91
92 try {
93 _generating_world = true;
94 if (_network_dedicated) Debug(net, 3, "Generating map, please wait...");
95 /* Set the Random() seed to generation_seed so we produce the same map with the same seed */
96 _random.SetSeed(_settings_game.game_creation.generation_seed);
97 SetGeneratingWorldProgress(GWP_MAP_INIT, 2);
98 SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, HT_NONE, WC_MAIN_WINDOW, 0);
99
100 BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP);
101
102 IncreaseGeneratingWorldProgress(GWP_MAP_INIT);
103 /* Must start economy early because of the costs. */
104 StartupEconomy();
105
106 /* Don't generate landscape items when in the scenario editor. */
107 if (_gw.mode == GWM_EMPTY) {
108 SetGeneratingWorldProgress(GWP_OBJECT, 1);
109
110 /* Make sure the tiles at the north border are void tiles if needed. */
111 if (_settings_game.construction.freeform_edges) {
112 for (uint x = 0; x < MapSizeX(); x++) MakeVoid(TileXY(x, 0));
113 for (uint y = 0; y < MapSizeY(); y++) MakeVoid(TileXY(0, y));
114 }
115
116 /* Make the map the height of the setting */
117 if (_game_mode != GM_MENU) FlatEmptyWorld(_settings_game.game_creation.se_flat_world_height);
118
119 ConvertGroundTilesIntoWaterTiles();
120 IncreaseGeneratingWorldProgress(GWP_OBJECT);
121
122 _settings_game.game_creation.snow_line_height = DEF_SNOWLINE_HEIGHT;
123 } else {
124 GenerateLandscape(_gw.mode);
125 GenerateClearTile();
126
127 /* Only generate towns, tree and industries in newgame mode. */
128 if (_game_mode != GM_EDITOR) {
129 if (!GenerateTowns(_settings_game.economy.town_layout)) {
130 HandleGeneratingWorldAbortion();
131 return;
132 }
133 GenerateIndustries();
134 GenerateObjects();
135 GenerateTrees();
136 }
137 }
138
139 /* These are probably pointless when inside the scenario editor. */
140 SetGeneratingWorldProgress(GWP_GAME_INIT, 3);
141 StartupCompanies();
142 IncreaseGeneratingWorldProgress(GWP_GAME_INIT);
143 StartupEngines();
144 IncreaseGeneratingWorldProgress(GWP_GAME_INIT);
145 StartupDisasters();
146 _generating_world = false;
147
148 /* No need to run the tile loop in the scenario editor. */
149 if (_gw.mode != GWM_EMPTY) {
150 uint i;
151
152 SetGeneratingWorldProgress(GWP_RUNTILELOOP, 0x500);
153 for (i = 0; i < 0x500; i++) {
154 RunTileLoop();
155 _tick_counter++;
156 IncreaseGeneratingWorldProgress(GWP_RUNTILELOOP);
157 }
158
159 if (_game_mode != GM_EDITOR) {
160 Game::StartNew();
161
162 if (Game::GetInstance() != nullptr) {
163 SetGeneratingWorldProgress(GWP_RUNSCRIPT, 2500);
164 _generating_world = true;
165 for (i = 0; i < 2500; i++) {
166 Game::GameLoop();
167 IncreaseGeneratingWorldProgress(GWP_RUNSCRIPT);
168 if (Game::GetInstance()->IsSleeping()) break;
169 }
170 _generating_world = false;
171 }
172 }
173 }
174
175 BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP);
176
177 ResetObjectToPlace();
178 _cur_company.Trash();
179 _current_company = _local_company = _gw.lc;
180
181 SetGeneratingWorldProgress(GWP_GAME_START, 1);
182 /* Call any callback */
183 if (_gw.proc != nullptr) _gw.proc();
184 IncreaseGeneratingWorldProgress(GWP_GAME_START);
185
186 CleanupGeneration();
187
188 ShowNewGRFError();
189
190 if (_network_dedicated) Debug(net, 3, "Map generated, starting game");
191 Debug(desync, 1, "new_map: {:08x}", _settings_game.game_creation.generation_seed);
192
193 if (_debug_desync_level > 0) {
194 char name[MAX_PATH];
195 seprintf(name, lastof(name), "dmp_cmds_%08x_%08x.sav", _settings_game.game_creation.generation_seed, _date);
196 SaveOrLoad(name, SLO_SAVE, DFT_GAME_FILE, AUTOSAVE_DIR, false);
197 }
198 } catch (AbortGenerateWorldSignal&) {
199 CleanupGeneration();
200
201 BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP, true);
202 if (_cur_company.IsValid()) _cur_company.Restore();
203
204 if (_network_dedicated) {
205 /* Exit the game to prevent a return to main menu. */
206 Debug(net, 0, "Generating map failed; closing server");
207 _exit_game = true;
208 } else {
209 SwitchToMode(_switch_mode);
210 }
211 }
212 }
213
219 void GenerateWorldSetCallback(GWDoneProc *proc)
220 {
221 _gw.proc = proc;
222 }
223
229 void GenerateWorldSetAbortCallback(GWAbortProc *proc)
230 {
231 _gw.abortp = proc;
232 }
233
237 void AbortGeneratingWorld()
238 {
239 _gw.abort = true;
240 }
241
246 bool IsGeneratingWorldAborted()
247 {
248 return _gw.abort || _exit_game;
249 }
250
254 void HandleGeneratingWorldAbortion()
255 {
256 /* Clean up - in SE create an empty map, otherwise, go to intro menu */
257 _switch_mode = (_game_mode == GM_EDITOR) ? SM_EDITOR : SM_MENU;
258
259 if (_gw.abortp != nullptr) _gw.abortp();
260
261 throw AbortGenerateWorldSignal();
262 }
263
271 void GenerateWorld(GenWorldMode mode, uint size_x, uint size_y, bool reset_settings)
272 {
273 if (HasModalProgress()) return;
274 _gw.mode = mode;
275 _gw.size_x = size_x;
276 _gw.size_y = size_y;
277 SetModalProgress(true);
278 _gw.abort = false;
279 _gw.abortp = nullptr;
280 _gw.lc = _local_company;
281
282 /* This disables some commands and stuff */
283 SetLocalCompany(COMPANY_SPECTATOR);
284
285 InitializeGame(_gw.size_x, _gw.size_y, true, reset_settings);
286 PrepareGenerateWorldProgress();
287
288 if (_settings_game.construction.map_height_limit == 0) {
289 uint estimated_height = 0;
290
291 if (_gw.mode == GWM_EMPTY && _game_mode != GM_MENU) {
292 estimated_height = _settings_game.game_creation.se_flat_world_height;
293 } else if (_gw.mode == GWM_HEIGHTMAP) {
294 estimated_height = _settings_game.game_creation.heightmap_height;
295 } else if (_settings_game.game_creation.land_generator == LG_TERRAGENESIS) {
296 estimated_height = GetEstimationTGPMapHeight();
297 } else {
298 estimated_height = 0;
299 }
300
301 _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));
302 }
303
304 if (_settings_game.game_creation.generation_seed == GENERATE_NEW_SEED) _settings_game.game_creation.generation_seed = _settings_newgame.game_creation.generation_seed = InteractiveRandom();
305
306 /* Load the right landscape stuff, and the NewGRFs! */
307 GfxLoadSprites();
308 LoadStringWidthTable();
309
310 /* Re-init the windowing system */
311 ResetWindowSystem();
312
313 /* Create toolbars */
314 SetupColoursAndInitialWindow();
315 SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, HT_NONE, WC_MAIN_WINDOW, 0);
316
317 UnshowCriticalError();
318 CloseAllNonVitalWindows();
319 HideVitalWindows();
320
321 ShowGenerateWorldProgress();
322
323 /* Centre the view on the map */
324 if (FindWindowById(WC_MAIN_WINDOW, 0) != nullptr) {
325 ScrollMainWindowToTile(TileXY(MapSizeX() / 2, MapSizeY() / 2), true);
326 }
327
328 _GenerateWorld();
329 }
GenWorldInfo::size_y
uint size_y
Y-size of the map.
Definition: genworld.h:63
game.hpp
LoadStringWidthTable
void LoadStringWidthTable(bool monospace)
Initialize _stringwidth_table cache.
Definition: gfx.cpp:1446
ShowFirstError
void ShowFirstError()
Show the first error of the queue.
Definition: error_gui.cpp:342
GWP_GAME_INIT
@ GWP_GAME_INIT
Initialize the game.
Definition: genworld.h:78
SetMouseCursorBusy
void SetMouseCursorBusy(bool busy)
Set or unset the ZZZ cursor.
Definition: gfx.cpp:1908
ShowGenerateWorldProgress
void ShowGenerateWorldProgress()
Show the window where a user can follow the process of the map generation.
Definition: genworld_gui.cpp:1490
HideVitalWindows
void HideVitalWindows()
Close all always on-top windows to get an empty screen.
Definition: window.cpp:3360
GameCreationSettings::generation_seed
uint32 generation_seed
noise seed for world generation
Definition: settings_type.h:312
GenerateLandscape
void GenerateLandscape(byte mode)
Definition: landscape.cpp:1628
game_instance.hpp
GWP_RUNTILELOOP
@ GWP_RUNTILELOOP
Runs the tile loop 1280 times to make snow etc.
Definition: genworld.h:79
ScrollMainWindowToTile
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
Definition: viewport.cpp:2456
_GenerateWorld
static void _GenerateWorld()
The internal, real, generate function.
Definition: genworld.cpp:87
GenWorldInfo::abort
bool abort
Whether to abort the thread ASAP.
Definition: genworld.h:59
water.h
GenWorldInfo::lc
CompanyID lc
The local_company before generating.
Definition: genworld.h:61
tgp.h
_gw
GenWorldInfo _gw
Please only use this variable in genworld.h and genworld.cpp and nowhere else.
Definition: genworld.cpp:58
AbortGeneratingWorld
void AbortGeneratingWorld()
Initializes the abortion process.
Definition: genworld.cpp:237
EconomySettings::town_layout
TownLayout town_layout
select town layout,
Definition: settings_type.h:526
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
GenWorldInfo::abortp
GWAbortProc * abortp
Proc that is called when aborting (can be nullptr)
Definition: genworld.h:65
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:3234
SM_EDITOR
@ SM_EDITOR
Switch to scenario editor.
Definition: openttd.h:30
AbortGenerateWorldSignal
Definition: genworld.cpp:63
ConstructionSettings::map_height_limit
uint8 map_height_limit
the maximum allowed heightlevel
Definition: settings_type.h:342
GenWorldInfo::mode
GenWorldMode mode
What mode are we making a world in.
Definition: genworld.h:60
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:219
FindWindowById
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition: window.cpp:1161
void_map.h
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:103
DFT_GAME_FILE
@ DFT_GAME_FILE
Save game or scenario file.
Definition: fileio_type.h:31
saveload.h
_random
Randomizer _random
Random used in the game state calculations.
Definition: random_func.cpp:25
AUTOSAVE_DIR
@ AUTOSAVE_DIR
Subdirectory of save for autosaves.
Definition: fileio_type.h:111
GWAbortProc
void GWAbortProc()
Called when genworld is aborted.
Definition: genworld.h:55
GetEstimationTGPMapHeight
uint GetEstimationTGPMapHeight()
Get an overestimation of the highest peak TGP wants to generate.
Definition: tgp.cpp:253
town.h
DEF_SNOWLINE_HEIGHT
static const uint DEF_SNOWLINE_HEIGHT
Default snowline height.
Definition: tile_type.h:33
StartupEngines
void StartupEngines()
Start/initialise all our engines.
Definition: engine.cpp:719
GENERATE_NEW_SEED
static const uint32 GENERATE_NEW_SEED
Create a new random seed.
Definition: genworld.h:24
genworld.h
GameCreationSettings::heightmap_height
byte heightmap_height
highest mountain for heightmap (towards what it scales)
Definition: settings_type.h:322
IncreaseGeneratingWorldProgress
void IncreaseGeneratingWorldProgress(GenWorldProgress cls)
Increases the current stage of the world generation with one.
Definition: genworld_gui.cpp:1572
ShowNewGRFError
void ShowNewGRFError()
Show the first NewGRF error we can find.
Definition: newgrf_gui.cpp:44
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition: settings_type.h:587
MapSizeX
static uint MapSizeX()
Get the size of the map along the X.
Definition: map_func.h:72
GenWorldInfo::proc
GWDoneProc * proc
Proc that is called when done (can be nullptr)
Definition: genworld.h:64
WC_MODAL_PROGRESS
@ WC_MODAL_PROGRESS
Progress report of landscape generation; Window numbers:
Definition: window_type.h:456
heightmap.h
ShowVitalWindows
void ShowVitalWindows()
Show the vital in-game windows.
Definition: main_gui.cpp:566
GWM_HEIGHTMAP
@ GWM_HEIGHTMAP
Generate a newgame from a heightmap.
Definition: genworld.h:31
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
SLO_SAVE
@ SLO_SAVE
File is being saved.
Definition: fileio_type.h:50
tilehighlight_func.h
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
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:229
MakeVoid
static void MakeVoid(TileIndex t)
Make a nice void tile ;)
Definition: void_map.h:19
GenerateTrees
void GenerateTrees()
Place new trees.
Definition: tree_cmd.cpp:355
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:54
PSM_ENTER_GAMELOOP
@ PSM_ENTER_GAMELOOP
Enter the gameloop, changes will be permanent.
Definition: newgrf_storage.h:20
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
GameSettings::economy
EconomySettings economy
settings to change the economy
Definition: settings_type.h:596
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
GameCreationSettings::snow_line_height
byte snow_line_height
the configured snow line height (deduced from "snow_coverage")
Definition: settings_type.h:319
safeguards.h
GWP_GAME_START
@ GWP_GAME_START
Really prepare to start the game.
Definition: genworld.h:81
GWP_OBJECT
@ GWP_OBJECT
Generate objects (radio tower, light houses)
Definition: genworld.h:76
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition: settings_type.h:354
GWP_MAP_INIT
@ GWP_MAP_INIT
Initialize/allocate the map, start economy.
Definition: genworld.h:70
GameCreationSettings::se_flat_world_height
byte se_flat_world_height
land height a flat world gets in SE
Definition: settings_type.h:326
HT_NONE
@ HT_NONE
default
Definition: tilehighlight_type.h:20
gfxinit.h
error.h
MapSizeY
static uint MapSizeY()
Get the size of the map along the Y.
Definition: map_func.h:82
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:61
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
date_func.h
stdafx.h
landscape.h
viewport_func.h
FlatEmptyWorld
void FlatEmptyWorld(byte tile_height)
Make an empty world where all tiles are of height 'tile_height'.
Definition: heightmap.cpp:544
Backup::IsValid
bool IsValid() const
Checks whether the variable was already restored.
Definition: backup_type.hpp:63
GenWorldInfo
Properties of current genworld process.
Definition: genworld.h:58
_generating_world
bool _generating_world
Whether we are generating the map or not.
Definition: genworld.cpp:61
string_func.h
_switch_mode
SwitchMode _switch_mode
The next mainloop command.
Definition: gfx.cpp:49
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
Game::GameLoop
static void GameLoop()
Called every game-tick to let Game do something.
Definition: game_core.cpp:31
Backup::Trash
void Trash()
Trash the backup.
Definition: backup_type.hpp:103
GenerateTowns
bool GenerateTowns(TownLayout layout)
This function will generate a certain amount of towns, with a certain layout It can be called from th...
Definition: town_cmd.cpp:2230
PrepareGenerateWorldProgress
void PrepareGenerateWorldProgress()
Initializes the progress counters to the starting point.
Definition: genworld_gui.cpp:1478
HandleGeneratingWorldAbortion
void HandleGeneratingWorldAbortion()
Really handle the abortion, i.e.
Definition: genworld.cpp:254
TileXY
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:163
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
UnshowCriticalError
void UnshowCriticalError()
Unshow the critical error.
Definition: error_gui.cpp:356
GameCreationSettings::land_generator
byte land_generator
the landscape generator
Definition: settings_type.h:317
video_driver.hpp
COMPANY_SPECTATOR
@ COMPANY_SPECTATOR
The client is spectating.
Definition: company_type.h:35
SetGeneratingWorldProgress
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
Definition: genworld_gui.cpp:1558
CloseWindowByClass
void CloseWindowByClass(WindowClass cls)
Close all windows of a given class.
Definition: window.cpp:1203
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
GWM_EMPTY
@ GWM_EMPTY
Generate an empty map (sea-level)
Definition: genworld.h:29
newgrf.h
LG_TERRAGENESIS
@ LG_TERRAGENESIS
TerraGenesis Perlin landscape generator.
Definition: genworld.h:21
progress.h
seprintf
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Definition: string.cpp:554
WC_MAIN_WINDOW
@ WC_MAIN_WINDOW
Main window; Window numbers:
Definition: window_type.h:44
GfxLoadSprites
void GfxLoadSprites()
Initialise and load all the sprites.
Definition: gfxinit.cpp:344
company_func.h
SM_MENU
@ SM_MENU
Switch to game intro menu.
Definition: openttd.h:32
GenerateIndustries
void GenerateIndustries()
This function will create random industries during game creation.
Definition: industry_cmd.cpp:2334
network.h
window_func.h
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1767
StartupCompanies
void StartupCompanies()
Start the next competitor now.
Definition: company_cmd.cpp:600
random_func.hpp
GenWorldInfo::size_x
uint size_x
X-size of the map.
Definition: genworld.h:62
IsGeneratingWorldAborted
bool IsGeneratingWorldAborted()
Is the generation being aborted?
Definition: genworld.cpp:246
GenerateWorld
void GenerateWorld(GenWorldMode mode, uint size_x, uint size_y, bool reset_settings)
Generate a world.
Definition: genworld.cpp:271
PSM_LEAVE_GAMELOOP
@ PSM_LEAVE_GAMELOOP
Leave the gameloop, changes will be temporary.
Definition: newgrf_storage.h:21
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:55
CleanupGeneration
static void CleanupGeneration()
Generation is done; show windows again and delete the progress window.
Definition: genworld.cpp:68
ResetWindowSystem
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition: window.cpp:1873
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:588
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:3319
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:3386
HasModalProgress
static bool HasModalProgress()
Check if we are currently in a modal progress state.
Definition: progress.h:17
Randomizer::SetSeed
void SetSeed(uint32 seed)
(Re)set the state of the random number generator.
Definition: random_func.cpp:55
GenWorldMode
GenWorldMode
Modes for GenerateWorld.
Definition: genworld.h:27
GWDoneProc
void GWDoneProc()
Procedure called when the genworld process finishes.
Definition: genworld.h:54
SetModalProgress
void SetModalProgress(bool state)
Set the modal progress state.
Definition: progress.cpp:22
_tick_counter
uint64 _tick_counter
Ever incrementing tick counter for setting off various events.
Definition: date.cpp:30
Game::GetInstance
static class GameInstance * GetInstance()
Get the current active instance.
Definition: game.hpp:106
thread.h
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:402
ResetObjectToPlace
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows).
Definition: viewport.cpp:3434
Game::StartNew
static void StartNew()
Start up a new GameScript.
Definition: game_core.cpp:72
_settings_newgame
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition: settings.cpp:55
SetupColoursAndInitialWindow
void SetupColoursAndInitialWindow()
Initialise the default colours (remaps and the likes), and load the main windows.
Definition: main_gui.cpp:538
engine_func.h
GWP_RUNSCRIPT
@ GWP_RUNSCRIPT
Runs the game script at most 2500 times, or when ever the script sleeps.
Definition: genworld.h:80
RunTileLoop
void RunTileLoop()
Gradually iterate over all tiles on the map, calling their TileLoopProcs once every 256 ticks.
Definition: landscape.cpp:807
backup_type.hpp