OpenTTD Source  1.11.2
ai_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 "../core/bitmath_func.hpp"
13 #include "../company_base.h"
14 #include "../company_func.h"
15 #include "../network/network.h"
16 #include "../window_func.h"
17 #include "../framerate_type.h"
18 #include "ai_scanner.hpp"
19 #include "ai_instance.hpp"
20 #include "ai_config.hpp"
21 #include "ai_info.hpp"
22 #include "ai.hpp"
23 
24 #include "../safeguards.h"
25 
26 /* static */ uint AI::frame_counter = 0;
27 /* static */ AIScannerInfo *AI::scanner_info = nullptr;
28 /* static */ AIScannerLibrary *AI::scanner_library = nullptr;
29 
30 /* static */ bool AI::CanStartNew()
31 {
32  /* Only allow new AIs on the server and only when that is allowed in multiplayer */
34 }
35 
36 /* static */ void AI::StartNew(CompanyID company, bool rerandomise_ai)
37 {
38  assert(Company::IsValidID(company));
39 
40  /* Clients shouldn't start AIs */
41  if (_networking && !_network_server) return;
42 
44  AIInfo *info = config->GetInfo();
45  if (info == nullptr || (rerandomise_ai && config->IsRandom())) {
47  assert(info != nullptr);
48  /* Load default data and store the name in the settings */
49  config->Change(info->GetName(), -1, false, true);
50  }
52 
53  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
54  Company *c = Company::Get(company);
55 
56  c->ai_info = info;
57  assert(c->ai_instance == nullptr);
58  c->ai_instance = new AIInstance();
59  c->ai_instance->Initialize(info);
60 
61  cur_company.Restore();
62 
64  return;
65 }
66 
67 /* static */ void AI::GameLoop()
68 {
69  /* If we are in networking, only servers run this function, and that only if it is allowed */
71 
72  /* The speed with which AIs go, is limited by the 'competitor_speed' */
75  if ((AI::frame_counter & ((1 << (4 - _settings_game.difficulty.competitor_speed)) - 1)) != 0) return;
76 
77  Backup<CompanyID> cur_company(_current_company, FILE_LINE);
78  for (const Company *c : Company::Iterate()) {
79  if (c->is_ai) {
80  PerformanceMeasurer framerate((PerformanceElement)(PFE_AI0 + c->index));
81  cur_company.Change(c->index);
82  c->ai_instance->GameLoop();
83  } else {
85  }
86  }
87  cur_company.Restore();
88 
89  /* Occasionally collect garbage; every 255 ticks do one company.
90  * Effectively collecting garbage once every two months per AI. */
91  if ((AI::frame_counter & 255) == 0) {
93  if (Company::IsValidAiID(cid)) Company::Get(cid)->ai_instance->CollectGarbage();
94  }
95 }
96 
97 /* static */ uint AI::GetTick()
98 {
99  return AI::frame_counter;
100 }
101 
102 /* static */ void AI::Stop(CompanyID company)
103 {
104  if (_networking && !_network_server) return;
106 
107  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
108  Company *c = Company::Get(company);
109 
110  delete c->ai_instance;
111  c->ai_instance = nullptr;
112  c->ai_info = nullptr;
113 
114  cur_company.Restore();
115 
118 }
119 
120 /* static */ void AI::Pause(CompanyID company)
121 {
122  /* The reason why dedicated servers are forbidden to execute this
123  * command is not because it is unsafe, but because there is no way
124  * for the server owner to unpause the script again. */
125  if (_network_dedicated) return;
126 
127  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
128  Company::Get(company)->ai_instance->Pause();
129 
130  cur_company.Restore();
131 }
132 
133 /* static */ void AI::Unpause(CompanyID company)
134 {
135  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
136  Company::Get(company)->ai_instance->Unpause();
137 
138  cur_company.Restore();
139 }
140 
141 /* static */ bool AI::IsPaused(CompanyID company)
142 {
143  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
144  bool paused = Company::Get(company)->ai_instance->IsPaused();
145 
146  cur_company.Restore();
147 
148  return paused;
149 }
150 
151 /* static */ void AI::KillAll()
152 {
153  /* It might happen there are no companies .. than we have nothing to loop */
154  if (Company::GetPoolSize() == 0) return;
155 
156  for (const Company *c : Company::Iterate()) {
157  if (c->is_ai) AI::Stop(c->index);
158  }
159 }
160 
161 /* static */ void AI::Initialize()
162 {
163  if (AI::scanner_info != nullptr) AI::Uninitialize(true);
164 
165  AI::frame_counter = 0;
166  if (AI::scanner_info == nullptr) {
169  AI::scanner_info->Initialize();
171  AI::scanner_library->Initialize();
172  }
173 }
174 
175 /* static */ void AI::Uninitialize(bool keepConfig)
176 {
177  AI::KillAll();
178 
179  if (keepConfig) {
180  /* Run a rescan, which indexes all AIInfos again, and check if we can
181  * still load all the AIS, while keeping the configs in place */
182  Rescan();
183  } else {
184  delete AI::scanner_info;
185  delete AI::scanner_library;
186  AI::scanner_info = nullptr;
187  AI::scanner_library = nullptr;
188 
189  for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
190  if (_settings_game.ai_config[c] != nullptr) {
191  delete _settings_game.ai_config[c];
192  _settings_game.ai_config[c] = nullptr;
193  }
194  if (_settings_newgame.ai_config[c] != nullptr) {
195  delete _settings_newgame.ai_config[c];
196  _settings_newgame.ai_config[c] = nullptr;
197  }
198  }
199  }
200 }
201 
202 /* static */ void AI::ResetConfig()
203 {
204  /* Check for both newgame as current game if we can reload the AIInfo inside
205  * the AIConfig. If not, remove the AI from the list (which will assign
206  * a random new AI on reload). */
207  for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
208  if (_settings_game.ai_config[c] != nullptr && _settings_game.ai_config[c]->HasScript()) {
209  if (!_settings_game.ai_config[c]->ResetInfo(true)) {
210  DEBUG(script, 0, "After a reload, the AI by the name '%s' was no longer found, and removed from the list.", _settings_game.ai_config[c]->GetName());
211  _settings_game.ai_config[c]->Change(nullptr);
212  if (Company::IsValidAiID(c)) {
213  /* The code belonging to an already running AI was deleted. We can only do
214  * one thing here to keep everything sane and that is kill the AI. After
215  * killing the offending AI we start a random other one in it's place, just
216  * like what would happen if the AI was missing during loading. */
217  AI::Stop(c);
218  AI::StartNew(c, false);
219  }
220  } else if (Company::IsValidAiID(c)) {
221  /* Update the reference in the Company struct. */
222  Company::Get(c)->ai_info = _settings_game.ai_config[c]->GetInfo();
223  }
224  }
225  if (_settings_newgame.ai_config[c] != nullptr && _settings_newgame.ai_config[c]->HasScript()) {
226  if (!_settings_newgame.ai_config[c]->ResetInfo(false)) {
227  DEBUG(script, 0, "After a reload, the AI by the name '%s' was no longer found, and removed from the list.", _settings_newgame.ai_config[c]->GetName());
228  _settings_newgame.ai_config[c]->Change(nullptr);
229  }
230  }
231  }
232 }
233 
234 /* static */ void AI::NewEvent(CompanyID company, ScriptEvent *event)
235 {
236  /* AddRef() and Release() need to be called at least once, so do it here */
237  event->AddRef();
238 
239  /* Clients should ignore events */
240  if (_networking && !_network_server) {
241  event->Release();
242  return;
243  }
244 
245  /* Only AIs can have an event-queue */
246  if (!Company::IsValidAiID(company)) {
247  event->Release();
248  return;
249  }
250 
251  /* Queue the event */
252  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
253  Company::Get(_current_company)->ai_instance->InsertEvent(event);
254  cur_company.Restore();
255 
256  event->Release();
257 }
258 
259 /* static */ void AI::BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company)
260 {
261  /* AddRef() and Release() need to be called at least once, so do it here */
262  event->AddRef();
263 
264  /* Clients should ignore events */
265  if (_networking && !_network_server) {
266  event->Release();
267  return;
268  }
269 
270  /* Try to send the event to all AIs */
271  for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
272  if (c != skip_company) AI::NewEvent(c, event);
273  }
274 
275  event->Release();
276 }
277 
278 /* static */ void AI::Save(CompanyID company)
279 {
280  if (!_networking || _network_server) {
281  Company *c = Company::GetIfValid(company);
282  assert(c != nullptr && c->ai_instance != nullptr);
283 
284  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
285  c->ai_instance->Save();
286  cur_company.Restore();
287  } else {
289  }
290 }
291 
292 /* static */ void AI::Load(CompanyID company, int version)
293 {
294  if (!_networking || _network_server) {
295  Company *c = Company::GetIfValid(company);
296  assert(c != nullptr && c->ai_instance != nullptr);
297 
298  Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
299  c->ai_instance->Load(version);
300  cur_company.Restore();
301  } else {
302  /* Read, but ignore, the load data */
304  }
305 }
306 
307 /* static */ int AI::GetStartNextTime()
308 {
309  /* Find the first company which doesn't exist yet */
310  for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
312  }
313 
314  /* Currently no AI can be started, check again in a year. */
315  return DAYS_IN_YEAR;
316 }
317 
318 /* static */ char *AI::GetConsoleList(char *p, const char *last, bool newest_only)
319 {
320  return AI::scanner_info->GetConsoleList(p, last, newest_only);
321 }
322 
323 /* static */ char *AI::GetConsoleLibraryList(char *p, const char *last)
324 {
325  return AI::scanner_library->GetConsoleList(p, last, true);
326 }
327 
328 /* static */ const ScriptInfoList *AI::GetInfoList()
329 {
330  return AI::scanner_info->GetInfoList();
331 }
332 
334 {
336 }
337 
338 /* static */ AIInfo *AI::FindInfo(const char *name, int version, bool force_exact_match)
339 {
340  return AI::scanner_info->FindInfo(name, version, force_exact_match);
341 }
342 
343 /* static */ AILibrary *AI::FindLibrary(const char *library, int version)
344 {
345  return AI::scanner_library->FindLibrary(library, version);
346 }
347 
348 /* static */ void AI::Rescan()
349 {
351 
354  ResetConfig();
355 
359 }
360 
367 /* static */ bool AI::HasAI(const ContentInfo *ci, bool md5sum)
368 {
369  return AI::scanner_info->HasScript(ci, md5sum);
370 }
371 
372 /* static */ bool AI::HasAILibrary(const ContentInfo *ci, bool md5sum)
373 {
374  return AI::scanner_library->HasScript(ci, md5sum);
375 }
376 
378 {
379  return AI::scanner_info;
380 }
381 
383 {
384  return AI::scanner_library;
385 }
386 
AI::Uninitialize
static void Uninitialize(bool keepConfig)
Uninitialize the AI system.
Definition: ai_core.cpp:175
AI::FindLibrary
static class AILibrary * FindLibrary(const char *library, int version)
Wrapper function for AIScanner::FindLibrary.
Definition: ai_core.cpp:343
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:3321
AIConfig
Definition: ai_config.hpp:16
GameSettings::ai_config
class AIConfig * ai_config[MAX_COMPANIES]
settings per company
Definition: settings_type.h:568
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:329
AI::GetScannerInfo
static AIScannerInfo * GetScannerInfo()
Gets the ScriptScanner instance that is used to find AIs.
Definition: ai_core.cpp:377
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
Pool::PoolItem<&_company_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:340
ScriptInstance::Save
void Save()
Call the script Save function and save all data in the savegame.
Definition: script_instance.cpp:472
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
TarScanner::DoScan
uint DoScan(Subdirectory sd)
Perform the scanning of a particular subdirectory.
Definition: fileio.cpp:572
AI::FindInfo
static class AIInfo * FindInfo(const char *name, int version, bool force_exact_match)
Wrapper function for AIScanner::FindInfo.
Definition: ai_core.cpp:338
_network_server
bool _network_server
network-server is active
Definition: network.cpp:53
AIScannerLibrary
Definition: ai_scanner.hpp:53
AI::Load
static void Load(CompanyID company, int version)
Load data for an AI from a savegame.
Definition: ai_core.cpp:292
AI::GetStartNextTime
static int GetStartNextTime()
Get the number of days before the next AI should start.
Definition: ai_core.cpp:307
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition: settings_type.h:563
AIInstance::Initialize
void Initialize(class AIInfo *info)
Initialize the AI and prepare it for its first run.
Definition: ai_instance.cpp:39
AIScannerInfo::FindInfo
class AIInfo * FindInfo(const char *nameParam, int versionParam, bool force_exact_match)
Check if we have an AI by name and version available in our list.
Definition: ai_scanner.cpp:94
PerformanceMeasurer
RAII class for measuring simple elements of performance.
Definition: framerate_type.h:92
AI::CanStartNew
static bool CanStartNew()
Is it possible to start a new AI company?
Definition: ai_core.cpp:30
DifficultySettings::competitor_speed
byte competitor_speed
the speed at which the AI builds
Definition: settings_type.h:70
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
ScriptScanner::GetConsoleList
char * GetConsoleList(char *p, const char *last, bool newest_only) const
Get the list of registered scripts to print on the console.
Definition: script_scanner.cpp:148
PerformanceMeasurer::SetInactive
static void SetInactive(PerformanceElement elem)
Mark a performance element as not currently in use.
Definition: framerate_gui.cpp:264
ScriptScanner::RescanDir
void RescanDir()
Rescan the script dir.
Definition: script_scanner.cpp:75
PerformanceElement
PerformanceElement
Elements of game performance that can be measured.
Definition: framerate_type.h:47
ScriptScanner::GetUniqueInfoList
const ScriptInfoList * GetUniqueInfoList()
Get the list of the latest version of all registered scripts.
Definition: script_scanner.hpp:50
ScriptInfo::version
int version
Version of the script.
Definition: script_info.hpp:161
ai.hpp
ai_info.hpp
COMPANY_FIRST
@ COMPANY_FIRST
First company, same as owner.
Definition: company_type.h:22
AI::Unpause
static void Unpause(CompanyID company)
Resume execution of the AI.
Definition: ai_core.cpp:133
Pool::PoolItem<&_company_pool >::GetPoolSize
static size_t GetPoolSize()
Returns first unused index.
Definition: pool_type.hpp:350
AIScannerLibrary::FindLibrary
class AILibrary * FindLibrary(const char *library, int version)
Find a library in the pool.
Definition: ai_scanner.cpp:151
AI::GetConsoleLibraryList
static char * GetConsoleLibraryList(char *p, const char *last)
Wrapper function for AIScanner::GetAIConsoleLibraryList.
Definition: ai_core.cpp:323
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:234
AI::scanner_library
static class AIScannerLibrary * scanner_library
ScriptScanner instance that is used to find AI Libraries.
Definition: ai.hpp:171
ScriptInfoList
std::map< const char *, class ScriptInfo *, StringCompare > ScriptInfoList
A list that maps AI names to their AIInfo object.
Definition: ai.hpp:19
AI::Save
static void Save(CompanyID company)
Save data from an AI to a savegame.
Definition: ai_core.cpp:278
DEBUG
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
ContentInfo
Container for all important information about a piece of content.
Definition: tcp_content_type.h:49
ScriptInstance::SaveEmpty
static void SaveEmpty()
Don't save any data in the savegame.
Definition: script_instance.cpp:466
ScriptConfig::GetName
const char * GetName() const
Get the name of the Script.
Definition: script_config.cpp:169
AI::StartNew
static void StartNew(CompanyID company, bool rerandomise_ai=true)
Start a new AI company.
Definition: ai_core.cpp:36
AILibrary
All static information from an AI library like name, version, etc.
Definition: ai_info.hpp:58
ai_instance.hpp
AIConfig::GetConfig
static AIConfig * GetConfig(CompanyID company, ScriptSettingSource source=SSS_DEFAULT)
Get the config of a company.
Definition: ai_config.cpp:45
AI::Pause
static void Pause(CompanyID company)
Suspend the AI and then pause execution of the script.
Definition: ai_core.cpp:120
AI::GetScannerLibrary
static AIScannerLibrary * GetScannerLibrary()
Gets the ScriptScanner instance that is used to find AI Libraries.
Definition: ai_core.cpp:382
AI::Initialize
static void Initialize()
Initialize the AI system.
Definition: ai_core.cpp:161
ScriptConfig::IsRandom
bool IsRandom() const
Is the current Script a randomly chosen Script?
Definition: script_config.cpp:164
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:80
AI::scanner_info
static class AIScannerInfo * scanner_info
ScriptScanner instance that is used to find AIs.
Definition: ai.hpp:170
MAX_COMPANIES
@ MAX_COMPANIES
Maximum number of companies.
Definition: company_type.h:23
AI::HasAI
static bool HasAI(const struct ContentInfo *ci, bool md5sum)
Wrapper function for AIScanner::HasAI.
Definition: ai_core.cpp:367
AI::BroadcastNewEvent
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=MAX_COMPANIES)
Broadcast a new event to all active AIs.
Definition: ai_core.cpp:259
AI::GetInfoList
static const ScriptInfoList * GetInfoList()
Wrapper function for AIScanner::GetAIInfoList.
Definition: ai_core.cpp:328
Company::IsValidAiID
static bool IsValidAiID(size_t index)
Is this company a valid company, controlled by the computer (a NoAI program)?
Definition: company_base.h:133
AIScannerInfo
Definition: ai_scanner.hpp:15
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:52
AI::GetTick
static uint GetTick()
Get the current AI tick.
Definition: ai_core.cpp:97
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:55
AI::GameLoop
static void GameLoop()
Called every game-tick to let AIs do something.
Definition: ai_core.cpp:67
ScriptInstance::LoadEmpty
static void LoadEmpty()
Load and discard data from a savegame.
Definition: script_instance.cpp:618
AI::IsPaused
static bool IsPaused(CompanyID company)
Checks if the AI is paused.
Definition: ai_core.cpp:141
AI::frame_counter
static uint frame_counter
Tick counter for the AI code.
Definition: ai.hpp:169
AI::GetConsoleList
static char * GetConsoleList(char *p, const char *last, bool newest_only=false)
Wrapper function for AIScanner::GetAIConsoleList.
Definition: ai_core.cpp:318
GameSettings::ai
AISettings ai
what may the AI do?
Definition: settings_type.h:566
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
WC_AI_DEBUG
@ WC_AI_DEBUG
AI debug window; Window numbers:
Definition: window_type.h:656
Pool::PoolItem<&_company_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:378
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:251
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:88
DeleteWindowById
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1165
ScriptScanner::GetInfoList
const ScriptInfoList * GetInfoList()
Get the list of all registered scripts.
Definition: script_scanner.hpp:45
AI::KillAll
static void KillAll()
Kill any and all AIs we manage.
Definition: ai_core.cpp:151
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
WC_AI_LIST
@ WC_AI_LIST
AI list; Window numbers:
Definition: window_type.h:277
TarScanner::AI
@ AI
Scan for AIs and its libraries.
Definition: fileio_func.h:89
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:3339
WC_AI_SETTINGS
@ WC_AI_SETTINGS
AI settings; Window numbers:
Definition: window_type.h:168
DAYS_IN_YEAR
static const int DAYS_IN_YEAR
days per year
Definition: date_type.h:29
ai_scanner.hpp
AIInfo
All static information from an AI like name, version, etc.
Definition: ai_info.hpp:16
AI::GetUniqueInfoList
static const ScriptInfoList * GetUniqueInfoList()
Wrapper function for AIScanner::GetUniqueAIInfoList.
Definition: ai_core.cpp:333
AIInstance
Runtime information about an AI like a pointer to the squirrel vm and the current state.
Definition: ai_instance.hpp:16
ScriptConfig::Change
void Change(const char *name, int version=-1, bool force_exact_match=false, bool is_random=false)
Set another Script to be loaded in this slot.
Definition: script_config.cpp:19
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:318
ScriptInstance::Load
void Load(int version)
Load data from a savegame and store it on the stack.
Definition: script_instance.cpp:627
ScriptInfo::GetName
const char * GetName() const
Get the Name of the script.
Definition: script_info.hpp:55
PFE_AI0
@ PFE_AI0
AI execution for player slot 1.
Definition: framerate_type.h:63
AI::Stop
static void Stop(CompanyID company)
Stop a company to be controlled by an AI.
Definition: ai_core.cpp:102
ScriptInfo::name
const char * name
Full name of the script.
Definition: script_info.hpp:156
AI::Rescan
static void Rescan()
Rescans all searchpaths for available AIs.
Definition: ai_core.cpp:348
Company
Definition: company_base.h:110
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3248
ScriptConfig::SSS_FORCE_GAME
@ SSS_FORCE_GAME
Get the Script config from the current game.
Definition: script_config.hpp:105
AI::ResetConfig
static void ResetConfig()
Reset all AIConfigs, and make them reload their AIInfo.
Definition: ai_core.cpp:202
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:159
AIConfig::GetSetting
int GetSetting(const char *name) const override
Get the value of a setting for this config.
Definition: ai_config.cpp:89
AISettings::ai_in_multiplayer
bool ai_in_multiplayer
so we allow AIs in multiplayer
Definition: settings_type.h:347
AIScannerInfo::SelectRandomAI
class AIInfo * SelectRandomAI() const
Select a random AI.
Definition: ai_scanner.cpp:60
_settings_newgame
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition: settings.cpp:81
AIConfig::ResetInfo
bool ResetInfo(bool force_exact_match)
When ever the AI Scanner is reloaded, all infos become invalid.
Definition: ai_config.cpp:67
ai_config.hpp