OpenTTD Source: src/ai/ai_core.cpp Source File

OpenTTD Source 14.1

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 */
33 return !_networking || (_network_server && _settings_game.ai.ai_in_multiplayer);
34 }
35
36 /* static */ void AI::StartNew(CompanyID company)
37 {
38 assert(Company::IsValidID(company));
39
40 /* Clients shouldn't start AIs */
41 if (_networking && !_network_server) return;
42
43 Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
44 Company *c = Company::Get(company);
45
46 AIConfig *config = c->ai_config.get();
47 if (config == nullptr) {
48 c->ai_config = std::make_unique<AIConfig>(AIConfig::GetConfig(company, AIConfig::SSS_FORCE_GAME));
49 config = c->ai_config.get();
50 }
51
52 AIInfo *info = config->GetInfo();
53 if (info == nullptr) {
54 info = AI::scanner_info->SelectRandomAI();
55 assert(info != nullptr);
56 /* Load default data and store the name in the settings */
57 config->Change(info->GetName(), -1, false);
58 }
59 config->AnchorUnchangeableSettings();
60
61 c->ai_info = info;
62 assert(c->ai_instance == nullptr);
63 c->ai_instance = new AIInstance();
64 c->ai_instance->Initialize(info);
65 c->ai_instance->LoadOnStack(config->GetToLoadData());
66 config->SetToLoadData(nullptr);
67
68 cur_company.Restore();
69
70 InvalidateWindowClassesData(WC_SCRIPT_DEBUG, -1);
71 return;
72 }
73
74 /* static */ void AI::GameLoop()
75 {
76 /* If we are in networking, only servers run this function, and that only if it is allowed */
77 if (_networking && (!_network_server || !_settings_game.ai.ai_in_multiplayer)) return;
78
79 /* The speed with which AIs go, is limited by the 'competitor_speed' */
80 AI::frame_counter++;
81 assert(_settings_game.difficulty.competitor_speed <= 4);
82 if ((AI::frame_counter & ((1 << (4 - _settings_game.difficulty.competitor_speed)) - 1)) != 0) return;
83
84 Backup<CompanyID> cur_company(_current_company, FILE_LINE);
85 for (const Company *c : Company::Iterate()) {
86 if (c->is_ai) {
87 PerformanceMeasurer framerate((PerformanceElement)(PFE_AI0 + c->index));
88 cur_company.Change(c->index);
89 c->ai_instance->GameLoop();
90 /* Occasionally collect garbage; every 255 ticks do one company.
91 * Effectively collecting garbage once every two months per AI. */
92 if ((AI::frame_counter & 255) == 0 && (CompanyID)GB(AI::frame_counter, 8, 4) == c->index) {
93 c->ai_instance->CollectGarbage();
94 }
95 } else {
96 PerformanceMeasurer::SetInactive((PerformanceElement)(PFE_AI0 + c->index));
97 }
98 }
99 cur_company.Restore();
100 }
101
102 /* static */ uint AI::GetTick()
103 {
104 return AI::frame_counter;
105 }
106
107 /* static */ void AI::Stop(CompanyID company)
108 {
109 if (_networking && !_network_server) return;
110 PerformanceMeasurer::SetInactive((PerformanceElement)(PFE_AI0 + company));
111
112 Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
113 Company *c = Company::Get(company);
114
115 delete c->ai_instance;
116 c->ai_instance = nullptr;
117 c->ai_info = nullptr;
118 c->ai_config.reset();
119
120 cur_company.Restore();
121
122 InvalidateWindowClassesData(WC_SCRIPT_DEBUG, -1);
123 }
124
125 /* static */ void AI::Pause(CompanyID company)
126 {
127 /* The reason why dedicated servers are forbidden to execute this
128 * command is not because it is unsafe, but because there is no way
129 * for the server owner to unpause the script again. */
130 if (_network_dedicated) return;
131
132 Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
133 Company::Get(company)->ai_instance->Pause();
134
135 cur_company.Restore();
136 }
137
138 /* static */ void AI::Unpause(CompanyID company)
139 {
140 Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
141 Company::Get(company)->ai_instance->Unpause();
142
143 cur_company.Restore();
144 }
145
146 /* static */ bool AI::IsPaused(CompanyID company)
147 {
148 Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
149 bool paused = Company::Get(company)->ai_instance->IsPaused();
150
151 cur_company.Restore();
152
153 return paused;
154 }
155
156 /* static */ void AI::KillAll()
157 {
158 /* It might happen there are no companies .. than we have nothing to loop */
159 if (Company::GetPoolSize() == 0) return;
160
161 for (const Company *c : Company::Iterate()) {
162 if (c->is_ai) AI::Stop(c->index);
163 }
164 }
165
166 /* static */ void AI::Initialize()
167 {
168 if (AI::scanner_info != nullptr) AI::Uninitialize(true);
169
170 AI::frame_counter = 0;
171 if (AI::scanner_info == nullptr) {
172 TarScanner::DoScan(TarScanner::AI);
173 AI::scanner_info = new AIScannerInfo();
174 AI::scanner_info->Initialize();
175 AI::scanner_library = new AIScannerLibrary();
176 AI::scanner_library->Initialize();
177 }
178 }
179
180 /* static */ void AI::Uninitialize(bool keepConfig)
181 {
182 AI::KillAll();
183
184 if (keepConfig) {
185 /* Run a rescan, which indexes all AIInfos again, and check if we can
186 * still load all the AIS, while keeping the configs in place */
187 Rescan();
188 } else {
189 delete AI::scanner_info;
190 delete AI::scanner_library;
191 AI::scanner_info = nullptr;
192 AI::scanner_library = nullptr;
193
194 for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
195 if (_settings_game.ai_config[c] != nullptr) {
196 delete _settings_game.ai_config[c];
197 _settings_game.ai_config[c] = nullptr;
198 }
199 if (_settings_newgame.ai_config[c] != nullptr) {
200 delete _settings_newgame.ai_config[c];
201 _settings_newgame.ai_config[c] = nullptr;
202 }
203 }
204 }
205 }
206
207 /* static */ void AI::ResetConfig()
208 {
209 /* Check for both newgame as current game if we can reload the AIInfo inside
210 * the AIConfig. If not, remove the AI from the list (which will assign
211 * a random new AI on reload). */
212 for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
213 if (_settings_game.ai_config[c] != nullptr && _settings_game.ai_config[c]->HasScript()) {
214 if (!_settings_game.ai_config[c]->ResetInfo(true)) {
215 Debug(script, 0, "After a reload, the AI by the name '{}' was no longer found, and removed from the list.", _settings_game.ai_config[c]->GetName());
216 _settings_game.ai_config[c]->Change(std::nullopt);
217 }
218 }
219
220 if (_settings_newgame.ai_config[c] != nullptr && _settings_newgame.ai_config[c]->HasScript()) {
221 if (!_settings_newgame.ai_config[c]->ResetInfo(false)) {
222 Debug(script, 0, "After a reload, the AI by the name '{}' was no longer found, and removed from the list.", _settings_newgame.ai_config[c]->GetName());
223 _settings_newgame.ai_config[c]->Change(std::nullopt);
224 }
225 }
226
227 if (Company::IsValidAiID(c) && Company::Get(c)->ai_config != nullptr) {
228 AIConfig *config = Company::Get(c)->ai_config.get();
229 if (!config->ResetInfo(true)) {
230 /* The code belonging to an already running AI was deleted. We can only do
231 * one thing here to keep everything sane and that is kill the AI. After
232 * killing the offending AI we start a random other one in it's place, just
233 * like what would happen if the AI was missing during loading. */
234 AI::Stop(c);
235 AI::StartNew(c);
236 } else {
237 /* Update the reference in the Company struct. */
238 Company::Get(c)->ai_info = config->GetInfo();
239 }
240 }
241 }
242 }
243
244 /* static */ void AI::NewEvent(CompanyID company, ScriptEvent *event)
245 {
246 /* AddRef() and Release() need to be called at least once, so do it here */
247 event->AddRef();
248
249 /* Clients should ignore events */
250 if (_networking && !_network_server) {
251 event->Release();
252 return;
253 }
254
255 /* Only AIs can have an event-queue */
256 if (!Company::IsValidAiID(company)) {
257 event->Release();
258 return;
259 }
260
261 /* Queue the event */
262 Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
263 Company::Get(_current_company)->ai_instance->InsertEvent(event);
264 cur_company.Restore();
265
266 event->Release();
267 }
268
269 /* static */ void AI::BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company)
270 {
271 /* AddRef() and Release() need to be called at least once, so do it here */
272 event->AddRef();
273
274 /* Clients should ignore events */
275 if (_networking && !_network_server) {
276 event->Release();
277 return;
278 }
279
280 /* Try to send the event to all AIs */
281 for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
282 if (c != skip_company) AI::NewEvent(c, event);
283 }
284
285 event->Release();
286 }
287
288 /* static */ void AI::Save(CompanyID company)
289 {
290 if (!_networking || _network_server) {
291 Company *c = Company::GetIfValid(company);
292 assert(c != nullptr);
293
294 /* When doing emergency saving, an AI can be not fully initialised. */
295 if (c->ai_instance != nullptr) {
296 Backup<CompanyID> cur_company(_current_company, company, FILE_LINE);
297 c->ai_instance->Save();
298 cur_company.Restore();
299 return;
300 }
301 }
302
303 AIInstance::SaveEmpty();
304 }
305
306 /* static */ void AI::GetConsoleList(std::back_insert_iterator<std::string> &output_iterator, bool newest_only)
307 {
308 AI::scanner_info->GetConsoleList(output_iterator, newest_only);
309 }
310
311 /* static */ void AI::GetConsoleLibraryList(std::back_insert_iterator<std::string> &output_iterator)
312 {
313 AI::scanner_library->GetConsoleList(output_iterator, true);
314 }
315
316 /* static */ const ScriptInfoList *AI::GetInfoList()
317 {
318 return AI::scanner_info->GetInfoList();
319 }
320
321 /* static */ const ScriptInfoList *AI::GetUniqueInfoList()
322 {
323 return AI::scanner_info->GetUniqueInfoList();
324 }
325
326 /* static */ AIInfo *AI::FindInfo(const std::string &name, int version, bool force_exact_match)
327 {
328 return AI::scanner_info->FindInfo(name, version, force_exact_match);
329 }
330
331 /* static */ AILibrary *AI::FindLibrary(const std::string &library, int version)
332 {
333 return AI::scanner_library->FindLibrary(library, version);
334 }
335
336 /* static */ void AI::Rescan()
337 {
338 TarScanner::DoScan(TarScanner::AI);
339
340 AI::scanner_info->RescanDir();
341 AI::scanner_library->RescanDir();
342 ResetConfig();
343
344 InvalidateWindowData(WC_SCRIPT_LIST, 0, 1);
345 SetWindowClassesDirty(WC_SCRIPT_DEBUG);
346 InvalidateWindowClassesData(WC_SCRIPT_SETTINGS);
347 }
348
355 /* static */ bool AI::HasAI(const ContentInfo *ci, bool md5sum)
356 {
357 return AI::scanner_info->HasScript(ci, md5sum);
358 }
359
360 /* static */ bool AI::HasAILibrary(const ContentInfo *ci, bool md5sum)
361 {
362 return AI::scanner_library->HasScript(ci, md5sum);
363 }
364
365 /* static */ AIScannerInfo *AI::GetScannerInfo()
366 {
367 return AI::scanner_info;
368 }
369
370 /* static */ AIScannerLibrary *AI::GetScannerLibrary()
371 {
372 return AI::scanner_library;
373 }
374
AI::Uninitialize
static void Uninitialize(bool keepConfig)
Uninitialize the AI system.
Definition: ai_core.cpp:180
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
AIConfig
Definition: ai_config.hpp:16
ScriptInfoList
std::map< std::string, class ScriptInfo *, CaseInsensitiveComparator > ScriptInfoList
Type for the list of scripts.
Definition: script_scanner.hpp:16
GameSettings::ai_config
class AIConfig * ai_config[MAX_COMPANIES]
settings per company
Definition: settings_type.h:622
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
AI::GetScannerInfo
static AIScannerInfo * GetScannerInfo()
Gets the ScriptScanner instance that is used to find AIs.
Definition: ai_core.cpp:365
Pool::PoolItem<&_company_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:350
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
AIScannerLibrary::FindLibrary
class AILibrary * FindLibrary(const std::string &library, int version)
Find a library in the pool.
Definition: ai_scanner.cpp:148
TarScanner::DoScan
uint DoScan(Subdirectory sd)
Perform the scanning of a particular subdirectory.
Definition: fileio.cpp:428
_network_server
bool _network_server
network-server is active
Definition: network.cpp:66
AIScannerLibrary
Definition: ai_scanner.hpp:53
GB
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition: settings_type.h:617
AIInstance::Initialize
void Initialize(class AIInfo *info)
Initialize the AI and prepare it for its first run.
Definition: ai_instance.cpp:40
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
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
DifficultySettings::competitor_speed
byte competitor_speed
the speed at which the AI builds
Definition: settings_type.h:106
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
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
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:49
AI::StartNew
static void StartNew(CompanyID company)
Start a new AI company.
Definition: ai_core.cpp:36
ScriptInfo::version
int version
Version of the script.
Definition: script_info.hpp:152
ai.hpp
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
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:138
Pool::PoolItem<&_company_pool >::GetPoolSize
static size_t GetPoolSize()
Returns first unused index.
Definition: pool_type.hpp:360
AI::GetConsoleLibraryList
static void GetConsoleLibraryList(std::back_insert_iterator< std::string > &output_iterator)
Wrapper function for AIScanner::GetAIConsoleLibraryList.
Definition: ai_core.cpp:311
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:244
AI::scanner_library
static class AIScannerLibrary * scanner_library
ScriptScanner instance that is used to find AI Libraries.
Definition: ai.hpp:143
AI::Save
static void Save(CompanyID company)
Save data from an AI to a savegame.
Definition: ai_core.cpp:288
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
AILibrary
All static information from an AI library like name, version, etc.
Definition: ai_info.hpp:57
ai_instance.hpp
AIConfig::GetConfig
static AIConfig * GetConfig(CompanyID company, ScriptSettingSource source=SSS_DEFAULT)
Get the config of a company.
Definition: ai_config.cpp:20
AI::Pause
static void Pause(CompanyID company)
Suspend the AI and then pause execution of the script.
Definition: ai_core.cpp:125
AI::GetScannerLibrary
static AIScannerLibrary * GetScannerLibrary()
Gets the ScriptScanner instance that is used to find AI Libraries.
Definition: ai_core.cpp:370
AI::Initialize
static void Initialize()
Initialize the AI system.
Definition: ai_core.cpp:166
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
AI::scanner_info
static class AIScannerInfo * scanner_info
ScriptScanner instance that is used to find AIs.
Definition: ai.hpp:142
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:355
AI::BroadcastNewEvent
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=MAX_COMPANIES)
Broadcast a new event to all active AIs.
Definition: ai_core.cpp:269
ScriptInfo::GetName
const std::string & GetName() const
Get the Name of the script.
Definition: script_info.hpp:46
AI::GetInfoList
static const ScriptInfoList * GetInfoList()
Wrapper function for AIScanner::GetAIInfoList.
Definition: ai_core.cpp:316
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:154
AIScannerInfo
Definition: ai_scanner.hpp:15
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:65
AI::GetTick
static uint GetTick()
Get the current AI tick.
Definition: ai_core.cpp:102
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:68
AI::GameLoop
static void GameLoop()
Called every game-tick to let AIs do something.
Definition: ai_core.cpp:74
AI::FindLibrary
static class AILibrary * FindLibrary(const std::string &library, int version)
Wrapper function for AIScanner::FindLibrary.
Definition: ai_core.cpp:331
AI::IsPaused
static bool IsPaused(CompanyID company)
Checks if the AI is paused.
Definition: ai_core.cpp:146
AI::frame_counter
static uint frame_counter
Tick counter for the AI code.
Definition: ai.hpp:141
GameSettings::ai
AISettings ai
what may the AI do?
Definition: settings_type.h:620
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:51
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:388
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
AI::KillAll
static void KillAll()
Kill any and all AIs we manage.
Definition: ai_core.cpp:156
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
TarScanner::AI
@ AI
Scan for AIs and its libraries.
Definition: fileio_func.h:67
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
ScriptInfo::name
std::string name
Full name of the script.
Definition: script_info.hpp:147
ScriptInstance::LoadOnStack
void LoadOnStack(ScriptData *data)
Store loaded data on the stack.
Definition: script_instance.cpp:690
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:321
AIInstance
Runtime information about an AI like a pointer to the squirrel vm and the current state.
Definition: ai_instance.hpp:16
AI::GetConsoleList
static void GetConsoleList(std::back_insert_iterator< std::string > &output_iterator, bool newest_only)
Wrapper function for AIScanner::GetAIConsoleList.
Definition: ai_core.cpp:306
AI::FindInfo
static class AIInfo * FindInfo(const std::string &name, int version, bool force_exact_match)
Wrapper function for AIScanner::FindInfo.
Definition: ai_core.cpp:326
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:328
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:107
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
AI::Rescan
static void Rescan()
Rescans all searchpaths for available AIs.
Definition: ai_core.cpp:336
Company
Definition: company_base.h:129
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
AI::ResetConfig
static void ResetConfig()
Reset all AIConfigs, and make them reload their AIInfo.
Definition: ai_core.cpp:207
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
AIScannerInfo::FindInfo
class AIInfo * FindInfo(const std::string &name, int version, bool force_exact_match)
Check if we have an AI by name and version available in our list.
Definition: ai_scanner.cpp:95
AISettings::ai_in_multiplayer
bool ai_in_multiplayer
so we allow AIs in multiplayer
Definition: settings_type.h:398
AIScannerInfo::SelectRandomAI
class AIInfo * SelectRandomAI() const
Select a random AI.
Definition: ai_scanner.cpp:61
_settings_newgame
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition: settings.cpp:56
AIConfig::ResetInfo
bool ResetInfo(bool force_exact_match)
When ever the AI Scanner is reloaded, all infos become invalid.
Definition: ai_config.cpp:48
ai_config.hpp
ScriptConfig::GetName
const std::string & GetName() const
Get the name of the Script.
Definition: script_config.cpp:131