OpenTTD Source: src/game/game_core.cpp Source File

OpenTTD Source 14.0-RC3

game_core.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 "../core/backup_type.hpp"
12 #include "../company_base.h"
13 #include "../company_func.h"
14 #include "../network/network.h"
15 #include "../window_func.h"
16 #include "../framerate_type.h"
17 #include "game.hpp"
18 #include "game_scanner.hpp"
19 #include "game_config.hpp"
20 #include "game_instance.hpp"
21 #include "game_info.hpp"
22
23 #include "../safeguards.h"
24
25 /* static */ uint Game::frame_counter = 0;
26 /* static */ GameInfo *Game::info = nullptr;
27 /* static */ GameInstance *Game::instance = nullptr;
28 /* static */ GameScannerInfo *Game::scanner_info = nullptr;
29 /* static */ GameScannerLibrary *Game::scanner_library = nullptr;
30
31 /* static */ void Game::GameLoop()
32 {
33 if (_networking && !_network_server) {
34 PerformanceMeasurer::SetInactive(PFE_GAMESCRIPT);
35 return;
36 }
37 if (Game::instance == nullptr) {
38 PerformanceMeasurer::SetInactive(PFE_GAMESCRIPT);
39 return;
40 }
41
42 PerformanceMeasurer framerate(PFE_GAMESCRIPT);
43
44 Game::frame_counter++;
45
46 Backup<CompanyID> cur_company(_current_company, FILE_LINE);
47 cur_company.Change(OWNER_DEITY);
48 Game::instance->GameLoop();
49 cur_company.Restore();
50
51 /* Occasionally collect garbage */
52 if ((Game::frame_counter & 255) == 0) {
53 Game::instance->CollectGarbage();
54 }
55 }
56
57 /* static */ void Game::Initialize()
58 {
59 if (Game::instance != nullptr) Game::Uninitialize(true);
60
61 Game::frame_counter = 0;
62
63 if (Game::scanner_info == nullptr) {
64 TarScanner::DoScan(TarScanner::GAME);
65 Game::scanner_info = new GameScannerInfo();
66 Game::scanner_info->Initialize();
67 Game::scanner_library = new GameScannerLibrary();
68 Game::scanner_library->Initialize();
69 }
70 }
71
72 /* static */ void Game::StartNew()
73 {
74 if (Game::instance != nullptr) return;
75
76 /* Don't start GameScripts in intro */
77 if (_game_mode == GM_MENU) return;
78
79 /* Clients shouldn't start GameScripts */
80 if (_networking && !_network_server) return;
81
82 GameConfig *config = GameConfig::GetConfig(GameConfig::SSS_FORCE_GAME);
83 GameInfo *info = config->GetInfo();
84 if (info == nullptr) return;
85
86 config->AnchorUnchangeableSettings();
87
88 Backup<CompanyID> cur_company(_current_company, FILE_LINE);
89 cur_company.Change(OWNER_DEITY);
90
91 Game::info = info;
92 Game::instance = new GameInstance();
93 Game::instance->Initialize(info);
94 Game::instance->LoadOnStack(config->GetToLoadData());
95 config->SetToLoadData(nullptr);
96
97 cur_company.Restore();
98
99 InvalidateWindowClassesData(WC_SCRIPT_DEBUG, -1);
100 }
101
102 /* static */ void Game::Uninitialize(bool keepConfig)
103 {
104 Backup<CompanyID> cur_company(_current_company, FILE_LINE);
105
106 delete Game::instance;
107 Game::instance = nullptr;
108 Game::info = nullptr;
109
110 cur_company.Restore();
111
112 if (keepConfig) {
113 Rescan();
114 } else {
115 delete Game::scanner_info;
116 delete Game::scanner_library;
117 Game::scanner_info = nullptr;
118 Game::scanner_library = nullptr;
119
120 if (_settings_game.game_config != nullptr) {
121 delete _settings_game.game_config;
122 _settings_game.game_config = nullptr;
123 }
124 if (_settings_newgame.game_config != nullptr) {
125 delete _settings_newgame.game_config;
126 _settings_newgame.game_config = nullptr;
127 }
128 }
129 }
130
131 /* static */ void Game::Pause()
132 {
133 if (Game::instance != nullptr) Game::instance->Pause();
134 }
135
136 /* static */ void Game::Unpause()
137 {
138 if (Game::instance != nullptr) Game::instance->Unpause();
139 }
140
141 /* static */ bool Game::IsPaused()
142 {
143 return Game::instance != nullptr? Game::instance->IsPaused() : false;
144 }
145
146 /* static */ void Game::NewEvent(ScriptEvent *event)
147 {
148 /* AddRef() and Release() need to be called at least once, so do it here */
149 event->AddRef();
150
151 /* Clients should ignore events */
152 if (_networking && !_network_server) {
153 event->Release();
154 return;
155 }
156
157 /* Check if Game instance is alive */
158 if (Game::instance == nullptr) {
159 event->Release();
160 return;
161 }
162
163 /* Queue the event */
164 Backup<CompanyID> cur_company(_current_company, OWNER_DEITY, FILE_LINE);
165 Game::instance->InsertEvent(event);
166 cur_company.Restore();
167
168 event->Release();
169 }
170
171 /* static */ void Game::ResetConfig()
172 {
173 /* Check for both newgame as current game if we can reload the GameInfo inside
174 * the GameConfig. If not, remove the Game from the list. */
175 if (_settings_game.game_config != nullptr && _settings_game.game_config->HasScript()) {
176 if (!_settings_game.game_config->ResetInfo(true)) {
177 Debug(script, 0, "After a reload, the GameScript by the name '{}' was no longer found, and removed from the list.", _settings_game.game_config->GetName());
178 _settings_game.game_config->Change(std::nullopt);
179 if (Game::instance != nullptr) {
180 delete Game::instance;
181 Game::instance = nullptr;
182 Game::info = nullptr;
183 }
184 } else if (Game::instance != nullptr) {
185 Game::info = _settings_game.game_config->GetInfo();
186 }
187 }
188 if (_settings_newgame.game_config != nullptr && _settings_newgame.game_config->HasScript()) {
189 if (!_settings_newgame.game_config->ResetInfo(false)) {
190 Debug(script, 0, "After a reload, the GameScript by the name '{}' was no longer found, and removed from the list.", _settings_newgame.game_config->GetName());
191 _settings_newgame.game_config->Change(std::nullopt);
192 }
193 }
194 }
195
196 /* static */ void Game::Rescan()
197 {
198 TarScanner::DoScan(TarScanner::GAME);
199
200 Game::scanner_info->RescanDir();
201 Game::scanner_library->RescanDir();
202 ResetConfig();
203
204 InvalidateWindowData(WC_SCRIPT_LIST, 0, 1);
205 SetWindowClassesDirty(WC_SCRIPT_DEBUG);
206 InvalidateWindowClassesData(WC_SCRIPT_SETTINGS);
207 InvalidateWindowClassesData(WC_GAME_OPTIONS);
208 }
209
210
211 /* static */ void Game::Save()
212 {
213 if (Game::instance != nullptr && (!_networking || _network_server)) {
214 Backup<CompanyID> cur_company(_current_company, OWNER_DEITY, FILE_LINE);
215 Game::instance->Save();
216 cur_company.Restore();
217 } else {
218 GameInstance::SaveEmpty();
219 }
220 }
221
222 /* static */ void Game::GetConsoleList(std::back_insert_iterator<std::string> &output_iterator, bool newest_only)
223 {
224 Game::scanner_info->GetConsoleList(output_iterator, newest_only);
225 }
226
227 /* static */ void Game::GetConsoleLibraryList(std::back_insert_iterator<std::string> &output_iterator)
228 {
229 Game::scanner_library->GetConsoleList(output_iterator, true);
230 }
231
232 /* static */ const ScriptInfoList *Game::GetInfoList()
233 {
234 return Game::scanner_info->GetInfoList();
235 }
236
237 /* static */ const ScriptInfoList *Game::GetUniqueInfoList()
238 {
239 return Game::scanner_info->GetUniqueInfoList();
240 }
241
242 /* static */ GameInfo *Game::FindInfo(const std::string &name, int version, bool force_exact_match)
243 {
244 return Game::scanner_info->FindInfo(name, version, force_exact_match);
245 }
246
247 /* static */ GameLibrary *Game::FindLibrary(const std::string &library, int version)
248 {
249 return Game::scanner_library->FindLibrary(library, version);
250 }
251
258 /* static */ bool Game::HasGame(const ContentInfo *ci, bool md5sum)
259 {
260 return Game::scanner_info->HasScript(ci, md5sum);
261 }
262
263 /* static */ bool Game::HasGameLibrary(const ContentInfo *ci, bool md5sum)
264 {
265 return Game::scanner_library->HasScript(ci, md5sum);
266 }
267
268 /* static */ GameScannerInfo *Game::GetScannerInfo()
269 {
270 return Game::scanner_info;
271 }
272 /* static */ GameScannerLibrary *Game::GetScannerLibrary()
273 {
274 return Game::scanner_library;
275 }
game.hpp
Backup::Change
void Change(const U &new_value)
Change the value of the variable.
Definition: backup_type.hpp:84
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
WC_SCRIPT_DEBUG
@ WC_SCRIPT_DEBUG
Script debug window; Window numbers:
Definition: window_type.h:669
Game::IsPaused
static bool IsPaused()
Checks if the Game Script is paused.
Definition: game_core.cpp:141
ScriptInfoList
std::map< std::string, class ScriptInfo *, CaseInsensitiveComparator > ScriptInfoList
Type for the list of scripts.
Definition: script_scanner.hpp:16
game_instance.hpp
ScriptInstance::InsertEvent
void InsertEvent(class ScriptEvent *event)
Insert an event for this script.
Definition: script_instance.cpp:778
ScriptInstance::GameLoop
void GameLoop()
Run the GameLoop of a script.
Definition: script_instance.cpp:171
game_info.hpp
ScriptInstance::Save
void Save()
Call the script Save function and save all data in the savegame.
Definition: script_instance.cpp:476
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
GameScannerLibrary::FindLibrary
class GameLibrary * FindLibrary(const std::string &library, int version)
Find a library in the pool.
Definition: game_scanner.cpp:89
TarScanner::DoScan
uint DoScan(Subdirectory sd)
Perform the scanning of a particular subdirectory.
Definition: fileio.cpp:427
_network_server
bool _network_server
network-server is active
Definition: network.cpp:60
Game::frame_counter
static uint frame_counter
Tick counter for the Game code.
Definition: game.hpp:112
ScriptInstance::Unpause
void Unpause()
Resume execution of the script.
Definition: script_instance.cpp:555
GameScannerInfo
Definition: game_scanner.hpp:15
PerformanceMeasurer
RAII class for measuring simple elements of performance.
Definition: framerate_type.h:92
GameSettings::game_config
class GameConfig * game_config
settings for gamescript
Definition: settings_type.h:623
ScriptScanner::GetConsoleList
void GetConsoleList(std::back_insert_iterator< std::string > &output_iterator, bool newest_only) const
Get the list of registered scripts to print on the console.
Definition: script_scanner.cpp:141
Game::Unpause
static void Unpause()
Resume execution of the Game Script.
Definition: game_core.cpp:136
PerformanceMeasurer::SetInactive
static void SetInactive(PerformanceElement elem)
Mark a performance element as not currently in use.
Definition: framerate_gui.cpp:286
ScriptScanner::RescanDir
void RescanDir()
Rescan the script dir.
Definition: script_scanner.cpp:75
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
ScriptInstance::Pause
void Pause()
Suspends the script for the current tick and then pause the execution of script.
Definition: script_instance.cpp:546
ScriptScanner::GetUniqueInfoList
const ScriptInfoList * GetUniqueInfoList()
Get the list of the latest version of all registered scripts.
Definition: script_scanner.hpp:49
ScriptInfo::version
int version
Version of the script.
Definition: script_info.hpp:152
ScriptConfig::Change
void Change(std::optional< const std::string > name, int version=-1, bool force_exact_match=false)
Set another Script to be loaded in this slot.
Definition: script_config.cpp:21
Game::GetScannerLibrary
static GameScannerLibrary * GetScannerLibrary()
Gets the ScriptScanner instance that is used to find Game Libraries.
Definition: game_core.cpp:272
Game::FindInfo
static class GameInfo * FindInfo(const std::string &name, int version, bool force_exact_match)
Wrapper function for GameScannerInfo::FindInfo.
Definition: game_core.cpp:242
Game::scanner_library
static class GameScannerLibrary * scanner_library
Scanner for GS Libraries.
Definition: game.hpp:115
Game::GetConsoleLibraryList
static void GetConsoleLibraryList(std::back_insert_iterator< std::string > &output_iterator)
Wrapper function for GameScanner::GetConsoleLibraryList.
Definition: game_core.cpp:227
Game::GetConsoleList
static void GetConsoleList(std::back_insert_iterator< std::string > &output_iterator, bool newest_only)
Wrapper function for GameScanner::GetConsoleList.
Definition: game_core.cpp:222
ContentInfo
Container for all important information about a piece of content.
Definition: tcp_content_type.h:52
ScriptInstance::SaveEmpty
static void SaveEmpty()
Don't save any data in the savegame.
Definition: script_instance.cpp:470
GameConfig
Definition: game_config.hpp:15
Game::Pause
static void Pause()
Suspends the Game Script and then pause the execution of the script.
Definition: game_core.cpp:131
GameInstance::Initialize
void Initialize(class GameInfo *info)
Initialize the script and prepare it for its first run.
Definition: game_instance.cpp:34
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:146
Game::Uninitialize
static void Uninitialize(bool keepConfig)
Uninitialize the Game system.
Definition: game_core.cpp:102
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:59
TarScanner::GAME
@ GAME
Scan for game scripts.
Definition: fileio_func.h:69
GameInstance
Runtime information about a game script like a pointer to the squirrel vm and the current state.
Definition: game_instance.hpp:16
game_scanner.hpp
PFE_GAMESCRIPT
@ PFE_GAMESCRIPT
Game script execution.
Definition: framerate_type.h:62
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:51
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition: window_type.h:619
Game::GameLoop
static void GameLoop()
Called every game-tick to let Game do something.
Definition: game_core.cpp:31
ScriptScanner::HasScript
bool HasScript(const struct ContentInfo *ci, bool md5sum)
Check whether we have a script with the exact characteristics as ci.
Definition: script_scanner.cpp:237
ScriptConfig::AnchorUnchangeableSettings
void AnchorUnchangeableSettings()
As long as the default of a setting has not been changed, the value of the setting is not stored.
Definition: script_config.cpp:73
ScriptScanner::GetInfoList
const ScriptInfoList * GetInfoList()
Get the list of all registered scripts.
Definition: script_scanner.hpp:44
Game::info
static class GameInfo * info
Current selected GameInfo.
Definition: game.hpp:116
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
GameConfig::ResetInfo
bool ResetInfo(bool force_exact_match)
When ever the Game Scanner is reloaded, all infos become invalid.
Definition: game_config.cpp:40
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
GameConfig::GetConfig
static GameConfig * GetConfig(ScriptSettingSource source=SSS_DEFAULT)
Get the config of a company.
Definition: game_config.cpp:18
Game::HasGame
static bool HasGame(const struct ContentInfo *ci, bool md5sum)
Wrapper function for GameScanner::HasGame.
Definition: game_core.cpp:258
GameInfo
All static information from an Game like name, version, etc.
Definition: game_info.hpp:16
ScriptInfo::name
std::string name
Full name of the script.
Definition: script_info.hpp:147
GameScannerInfo::FindInfo
class GameInfo * FindInfo(const std::string &name, int version, bool force_exact_match)
Check if we have a game by name and version available in our list.
Definition: game_scanner.cpp:36
ScriptInstance::LoadOnStack
void LoadOnStack(ScriptData *data)
Store loaded data on the stack.
Definition: script_instance.cpp:690
OWNER_DEITY
@ OWNER_DEITY
The object is owned by a superuser / goal script.
Definition: company_type.h:27
Game::Save
static void Save()
Save data from a GameScript to a savegame.
Definition: game_core.cpp:211
GameLibrary
All static information from an Game library like name, version, etc.
Definition: game_info.hpp:49
Game::GetScannerInfo
static GameScannerInfo * GetScannerInfo()
Gets the ScriptScanner instance that is used to find Game scripts.
Definition: game_core.cpp:268
ScriptInstance::IsPaused
bool IsPaused()
Checks if the script is paused.
Definition: script_instance.cpp:560
ScriptInstance::CollectGarbage
void CollectGarbage()
Let the VM collect any garbage.
Definition: script_instance.cpp:260
Game::GetUniqueInfoList
static const ScriptInfoList * GetUniqueInfoList()
Wrapper function for GameScanner::GetUniqueInfoList.
Definition: game_core.cpp:237
GameScannerLibrary
Definition: game_scanner.hpp:37
Game::FindLibrary
static class GameLibrary * FindLibrary(const std::string &library, int version)
Wrapper function for GameScanner::FindLibrary.
Definition: game_core.cpp:247
WC_SCRIPT_SETTINGS
@ WC_SCRIPT_SETTINGS
Script settings; Window numbers:
Definition: window_type.h:175
WC_SCRIPT_LIST
@ WC_SCRIPT_LIST
Scripts list; Window numbers:
Definition: window_type.h:284
game_config.hpp
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3112
ScriptConfig::SSS_FORCE_GAME
@ SSS_FORCE_GAME
Get the Script config from the current game.
Definition: script_config.hpp:97
Game::StartNew
static void StartNew()
Start up a new GameScript.
Definition: game_core.cpp:72
ScriptConfig::HasScript
bool HasScript() const
Is this config attached to an Script? In other words, is there a Script that is assigned to this slot...
Definition: script_config.cpp:126
Game::scanner_info
static class GameScannerInfo * scanner_info
Scanner for Game scripts.
Definition: game.hpp:114
_settings_newgame
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition: settings.cpp:56
Game::instance
static class GameInstance * instance
Instance to the current active Game.
Definition: game.hpp:113
Game::GetInfoList
static const ScriptInfoList * GetInfoList()
Wrapper function for GameScanner::GetInfoList.
Definition: game_core.cpp:232
ScriptConfig::GetName
const std::string & GetName() const
Get the name of the Script.
Definition: script_config.cpp:131
Game::Initialize
static void Initialize()
Initialize the Game system.
Definition: game_core.cpp:57