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

OpenTTD Source 15.0-beta1

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);
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);
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);
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 ScriptObjectRef counter(event);
149
150 /* Clients should ignore events */
151 if (_networking && !_network_server) {
152 return;
153 }
154
155 /* Check if Game instance is alive */
156 if (Game::instance == nullptr) {
157 return;
158 }
159
160 /* Queue the event */
161 Backup<CompanyID> cur_company(_current_company, OWNER_DEITY);
162 Game::instance->InsertEvent(event);
163 cur_company.Restore();
164}
165
166/* static */ void Game::ResetConfig()
167{
168 /* Check for both newgame as current game if we can reload the GameInfo inside
169 * the GameConfig. If not, remove the Game from the list. */
170 if (_settings_game.game_config != nullptr && _settings_game.game_config->HasScript()) {
171 if (!_settings_game.game_config->ResetInfo(true)) {
172 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());
173 _settings_game.game_config->Change(std::nullopt);
174 if (Game::instance != nullptr) {
175 delete Game::instance;
176 Game::instance = nullptr;
177 Game::info = nullptr;
178 }
179 } else if (Game::instance != nullptr) {
180 Game::info = _settings_game.game_config->GetInfo();
181 }
182 }
183 if (_settings_newgame.game_config != nullptr && _settings_newgame.game_config->HasScript()) {
184 if (!_settings_newgame.game_config->ResetInfo(false)) {
185 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());
186 _settings_newgame.game_config->Change(std::nullopt);
187 }
188 }
189}
190
191/* static */ void Game::Rescan()
192{
193 TarScanner::DoScan(TarScanner::GAME);
194
195 Game::scanner_info->RescanDir();
196 Game::scanner_library->RescanDir();
197 ResetConfig();
198
199 InvalidateWindowData(WC_SCRIPT_LIST, 0, 1);
200 SetWindowClassesDirty(WC_SCRIPT_DEBUG);
201 InvalidateWindowClassesData(WC_SCRIPT_SETTINGS);
202 InvalidateWindowClassesData(WC_GAME_OPTIONS);
203}
204
205
206/* static */ void Game::Save()
207{
208 if (Game::instance != nullptr && (!_networking || _network_server)) {
209 Backup<CompanyID> cur_company(_current_company, OWNER_DEITY);
210 Game::instance->Save();
211 cur_company.Restore();
212 } else {
213 GameInstance::SaveEmpty();
214 }
215}
216
217/* static */ void Game::GetConsoleList(std::back_insert_iterator<std::string> &output_iterator, bool newest_only)
218{
219 Game::scanner_info->GetConsoleList(output_iterator, newest_only);
220}
221
222/* static */ void Game::GetConsoleLibraryList(std::back_insert_iterator<std::string> &output_iterator)
223{
224 Game::scanner_library->GetConsoleList(output_iterator, true);
225}
226
227/* static */ const ScriptInfoList *Game::GetInfoList()
228{
229 return Game::scanner_info->GetInfoList();
230}
231
232/* static */ const ScriptInfoList *Game::GetUniqueInfoList()
233{
234 return Game::scanner_info->GetUniqueInfoList();
235}
236
237/* static */ GameInfo *Game::FindInfo(const std::string &name, int version, bool force_exact_match)
238{
239 return Game::scanner_info->FindInfo(name, version, force_exact_match);
240}
241
242/* static */ GameLibrary *Game::FindLibrary(const std::string &library, int version)
243{
244 return Game::scanner_library->FindLibrary(library, version);
245}
246
253/* static */ bool Game::HasGame(const ContentInfo *ci, bool md5sum)
254{
255 return Game::scanner_info->HasScript(ci, md5sum);
256}
257
258/* static */ bool Game::HasGameLibrary(const ContentInfo *ci, bool md5sum)
259{
260 return Game::scanner_library->HasScript(ci, md5sum);
261}
262
263/* static */ GameScannerInfo *Game::GetScannerInfo()
264{
265 return Game::scanner_info;
266}
267/* static */ GameScannerLibrary *Game::GetScannerLibrary()
268{
269 return Game::scanner_library;
270}
GameConfig
Definition game_config.hpp:15
GameConfig::ResetInfo
bool ResetInfo(bool force_exact_match)
When ever the Game Scanner is reloaded, all infos become invalid.
Definition game_config.cpp:40
GameConfig::GetConfig
static GameConfig * GetConfig(ScriptSettingSource source=SSS_DEFAULT)
Get the config of a company.
Definition game_config.cpp:18
GameInfo
All static information from an Game like name, version, etc.
Definition game_info.hpp:16
GameInstance
Runtime information about a game script like a pointer to the squirrel vm and the current state.
Definition game_instance.hpp:16
GameInstance::Initialize
void Initialize(class GameInfo *info)
Initialize the script and prepare it for its first run.
Definition game_instance.cpp:34
GameLibrary
All static information from an Game library like name, version, etc.
Definition game_info.hpp:49
GameScannerInfo
Definition game_scanner.hpp:15
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
GameScannerLibrary
Definition game_scanner.hpp:37
GameScannerLibrary::FindLibrary
class GameLibrary * FindLibrary(const std::string &library, int version)
Find a library in the pool.
Definition game_scanner.cpp:89
Game::StartNew
static void StartNew()
Start up a new GameScript.
Definition game_core.cpp:72
Game::info
static class GameInfo * info
Current selected GameInfo.
Definition game.hpp:116
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:237
Game::GetScannerLibrary
static GameScannerLibrary * GetScannerLibrary()
Gets the ScriptScanner instance that is used to find Game Libraries.
Definition game_core.cpp:267
Game::Unpause
static void Unpause()
Resume execution of the Game Script.
Definition game_core.cpp:136
Game::IsPaused
static bool IsPaused()
Checks if the Game Script is paused.
Definition game_core.cpp:141
Game::frame_counter
static uint frame_counter
Tick counter for the Game code.
Definition game.hpp:112
Game::Save
static void Save()
Save data from a GameScript to a savegame.
Definition game_core.cpp:206
Game::scanner_info
static class GameScannerInfo * scanner_info
Scanner for Game scripts.
Definition game.hpp:114
Game::instance
static class GameInstance * instance
Instance to the current active Game.
Definition game.hpp:113
Game::scanner_library
static class GameScannerLibrary * scanner_library
Scanner for GS Libraries.
Definition game.hpp:115
Game::HasGame
static bool HasGame(const struct ContentInfo *ci, bool md5sum)
Wrapper function for GameScanner::HasGame.
Definition game_core.cpp:253
Game::FindLibrary
static class GameLibrary * FindLibrary(const std::string &library, int version)
Wrapper function for GameScanner::FindLibrary.
Definition game_core.cpp:242
Game::GetUniqueInfoList
static const ScriptInfoList * GetUniqueInfoList()
Wrapper function for GameScanner::GetUniqueInfoList.
Definition game_core.cpp:232
Game::Pause
static void Pause()
Suspends the Game Script and then pause the execution of the script.
Definition game_core.cpp:131
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition game_core.cpp:146
Game::GameLoop
static void GameLoop()
Called every game-tick to let Game do something.
Definition game_core.cpp:31
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:217
Game::GetConsoleLibraryList
static void GetConsoleLibraryList(std::back_insert_iterator< std::string > &output_iterator)
Wrapper function for GameScanner::GetConsoleLibraryList.
Definition game_core.cpp:222
Game::Uninitialize
static void Uninitialize(bool keepConfig)
Uninitialize the Game system.
Definition game_core.cpp:102
Game::GetInfoList
static const ScriptInfoList * GetInfoList()
Wrapper function for GameScanner::GetInfoList.
Definition game_core.cpp:227
Game::Initialize
static void Initialize()
Initialize the Game system.
Definition game_core.cpp:57
Game::GetScannerInfo
static GameScannerInfo * GetScannerInfo()
Gets the ScriptScanner instance that is used to find Game scripts.
Definition game_core.cpp:263
PerformanceMeasurer
RAII class for measuring simple elements of performance.
Definition framerate_type.h:92
PerformanceMeasurer::SetInactive
static void SetInactive(PerformanceElement elem)
Mark a performance element as not currently in use.
Definition framerate_gui.cpp:287
ScriptConfig::SSS_FORCE_GAME
@ SSS_FORCE_GAME
Get the Script config from the current game.
Definition script_config.hpp:96
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
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
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
ScriptConfig::GetName
const std::string & GetName() const
Get the name of the Script.
Definition script_config.cpp:131
ScriptInstance::InsertEvent
void InsertEvent(class ScriptEvent *event)
Insert an event for this script.
Definition script_instance.cpp:772
ScriptInstance::Unpause
void Unpause()
Resume execution of the script.
Definition script_instance.cpp:555
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
ScriptInstance::SaveEmpty
static void SaveEmpty()
Don't save any data in the savegame.
Definition script_instance.cpp:470
ScriptInstance::LoadOnStack
void LoadOnStack(ScriptData *data)
Store loaded data on the stack.
Definition script_instance.cpp:684
ScriptInstance::Save
void Save()
Call the script Save function and save all data in the savegame.
Definition script_instance.cpp:476
ScriptInstance::Pause
void Pause()
Suspends the script for the current tick and then pause the execution of script.
Definition script_instance.cpp:546
ScriptInstance::GameLoop
void GameLoop()
Run the GameLoop of a script.
Definition script_instance.cpp:171
ScriptScanner::GetInfoList
const ScriptInfoList * GetInfoList()
Get the list of all registered scripts.
Definition script_scanner.hpp:44
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:235
ScriptScanner::GetUniqueInfoList
const ScriptInfoList * GetUniqueInfoList()
Get the list of the latest version of all registered scripts.
Definition script_scanner.hpp:49
ScriptScanner::RescanDir
void RescanDir()
Rescan the script dir.
Definition script_scanner.cpp:75
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
TarScanner::DoScan
uint DoScan(Subdirectory sd)
Perform the scanning of a particular subdirectory.
Definition fileio.cpp:375
TarScanner::GAME
@ GAME
Scan for game scripts.
Definition fileio_func.h:69
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:53
OWNER_DEITY
@ OWNER_DEITY
The object is owned by a superuser / goal script.
Definition company_type.h:27
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition debug.h:37
PFE_GAMESCRIPT
@ PFE_GAMESCRIPT
Game script execution.
Definition framerate_type.h:62
game.hpp
Base functions for all Games.
game_config.hpp
GameConfig stores the configuration settings of every Game.
game_info.hpp
GameInfo keeps track of all information of an Game, like Author, Description, ...
game_instance.hpp
The GameInstance tracks games.
game_scanner.hpp
declarations of the class for Game scanner
_networking
bool _networking
are we in networking mode?
Definition network.cpp:65
_network_server
bool _network_server
network-server is active
Definition network.cpp:66
ScriptInfoList
std::map< std::string, class ScriptInfo *, CaseInsensitiveComparator > ScriptInfoList
Type for the list of scripts.
Definition script_scanner.hpp:16
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:57
_settings_newgame
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition settings.cpp:58
Backup
Class to backup a specific variable and restore it later.
Definition backup_type.hpp:21
Backup::Change
void Change(const U &new_value)
Change the value of the variable.
Definition backup_type.hpp:82
Backup::Restore
void Restore()
Restore the variable.
Definition backup_type.hpp:110
ContentInfo
Container for all important information about a piece of content.
Definition tcp_content_type.h:52
GameSettings::game_config
class GameConfig * game_config
settings for gamescript
Definition settings_type.h:598
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition window.cpp:3127
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:3219
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:3236
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
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition window_type.h:624
WC_SCRIPT_DEBUG
@ WC_SCRIPT_DEBUG
Script debug window; Window numbers:
Definition window_type.h:674