00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "../stdafx.h"
00013 #include "../debug.h"
00014 #include "../fileio_func.h"
00015 #include "../network/network.h"
00016 #include "../core/random_func.hpp"
00017
00018 #include "../script/squirrel_class.hpp"
00019 #include "ai_info.hpp"
00020 #include "ai_scanner.hpp"
00021 #include "api/ai_controller.hpp"
00022
00023 void AIScanner::RescanAIDir()
00024 {
00025
00026 this->Reset();
00027 this->ScanScriptDir("info.nut", AI_DIR);
00028 this->ScanScriptDir("library.nut", AI_LIBRARY_DIR);
00029 }
00030
00031 AIScanner::AIScanner() :
00032 ScriptScanner(),
00033 info_dummy(NULL)
00034 {
00035
00036 DefSQClass <AIInfo> SQAIInfo("AIInfo");
00037 SQAIInfo.PreRegister(engine);
00038 SQAIInfo.AddConstructor<void (AIInfo::*)(), 1>(engine, "x");
00039 SQAIInfo.DefSQAdvancedMethod(this->engine, &AIInfo::AddSetting, "AddSetting");
00040 SQAIInfo.DefSQAdvancedMethod(this->engine, &AIInfo::AddLabels, "AddLabels");
00041 SQAIInfo.DefSQConst(engine, AICONFIG_NONE, "AICONFIG_NONE");
00042 SQAIInfo.DefSQConst(engine, AICONFIG_RANDOM, "AICONFIG_RANDOM");
00043 SQAIInfo.DefSQConst(engine, AICONFIG_BOOLEAN, "AICONFIG_BOOLEAN");
00044 SQAIInfo.DefSQConst(engine, AICONFIG_INGAME, "AICONFIG_INGAME");
00045 SQAIInfo.PostRegister(engine);
00046 this->engine->AddMethod("RegisterAI", &AIInfo::Constructor, 2, "tx");
00047 this->engine->AddMethod("RegisterDummyAI", &AIInfo::DummyConstructor, 2, "tx");
00048
00049
00050 this->engine->AddClassBegin("AILibrary");
00051 this->engine->AddClassEnd();
00052 this->engine->AddMethod("RegisterLibrary", &AILibrary::Constructor, 2, "tx");
00053
00054
00055 this->RescanAIDir();
00056
00057
00058 this->engine->ResetCrashed();
00059 strecpy(this->main_script, "%_dummy", lastof(this->main_script));
00060 extern void AI_CreateAIInfoDummy(HSQUIRRELVM vm);
00061 AI_CreateAIInfoDummy(this->engine->GetVM());
00062 }
00063
00064 void AIScanner::Reset()
00065 {
00066 AIInfoList::iterator it = this->info_list.begin();
00067 for (; it != this->info_list.end(); it++) {
00068 free((void *)(*it).first);
00069 delete (*it).second;
00070 }
00071 it = this->info_single_list.begin();
00072 for (; it != this->info_single_list.end(); it++) {
00073 free((void *)(*it).first);
00074 }
00075 AILibraryList::iterator lit = this->library_list.begin();
00076 for (; lit != this->library_list.end(); lit++) {
00077 free((void *)(*lit).first);
00078 delete (*lit).second;
00079 }
00080
00081 this->info_list.clear();
00082 this->info_single_list.clear();
00083 this->library_list.clear();
00084 }
00085
00086 AIScanner::~AIScanner()
00087 {
00088 this->Reset();
00089
00090 delete this->info_dummy;
00091 }
00092
00093 bool AIScanner::ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm, AIController *controller)
00094 {
00095
00096 char library_name[1024];
00097 snprintf(library_name, sizeof(library_name), "%s.%d", library, version);
00098 strtolower(library_name);
00099
00100
00101 AILibraryList::iterator iter = this->library_list.find(library_name);
00102 if (iter == this->library_list.end()) {
00103 char error[1024];
00104
00105
00106 iter = this->library_list.find(library);
00107 if (iter == this->library_list.end()) {
00108 snprintf(error, sizeof(error), "couldn't find library '%s'", library);
00109 } else {
00110 snprintf(error, sizeof(error), "couldn't find library '%s' version %d. The latest version available is %d", library, version, (*iter).second->GetVersion());
00111 }
00112 sq_throwerror(vm, OTTD2SQ(error));
00113 return false;
00114 }
00115
00116
00117 HSQOBJECT parent;
00118 sq_getstackobj(vm, 1, &parent);
00119
00120 char fake_class[1024];
00121 int next_number;
00122
00123 if (!controller->LoadedLibrary(library_name, &next_number, &fake_class[0], sizeof(fake_class))) {
00124
00125 snprintf(fake_class, sizeof(fake_class), "_internalNA%d", next_number);
00126
00127
00128 sq_pushroottable(vm);
00129 sq_pushstring(vm, OTTD2SQ(fake_class), -1);
00130 sq_newclass(vm, SQFalse);
00131
00132 if (!Squirrel::LoadScript(vm, (*iter).second->GetMainScript(), false)) {
00133 char error[1024];
00134 snprintf(error, sizeof(error), "there was a compile error when importing '%s' version %d", library, version);
00135 sq_throwerror(vm, OTTD2SQ(error));
00136 return false;
00137 }
00138
00139 sq_newslot(vm, -3, SQFalse);
00140 sq_pop(vm, 1);
00141
00142 controller->AddLoadedLibrary(library_name, fake_class);
00143 }
00144
00145
00146 sq_pushroottable(vm);
00147 sq_pushstring(vm, OTTD2SQ(fake_class), -1);
00148 if (SQ_FAILED(sq_get(vm, -2))) {
00149 sq_throwerror(vm, _SC("internal error assigning library class"));
00150 return false;
00151 }
00152 sq_pushstring(vm, OTTD2SQ((*iter).second->GetInstanceName()), -1);
00153 if (SQ_FAILED(sq_get(vm, -2))) {
00154 char error[1024];
00155 snprintf(error, sizeof(error), "unable to find class '%s' in the library '%s' version %d", (*iter).second->GetInstanceName(), library, version);
00156 sq_throwerror(vm, OTTD2SQ(error));
00157 return false;
00158 }
00159 HSQOBJECT obj;
00160 sq_getstackobj(vm, -1, &obj);
00161 sq_pop(vm, 3);
00162
00163 if (StrEmpty(class_name)) {
00164 sq_pushobject(vm, obj);
00165 return true;
00166 }
00167
00168
00169 sq_pushobject(vm, parent);
00170 sq_pushstring(vm, OTTD2SQ(class_name), -1);
00171 sq_pushobject(vm, obj);
00172 sq_newclass(vm, SQTrue);
00173 sq_newslot(vm, -3, SQFalse);
00174 sq_pop(vm, 1);
00175
00176 sq_pushobject(vm, obj);
00177 return true;
00178 }
00179
00180 void AIScanner::RegisterLibrary(AILibrary *library)
00181 {
00182 char library_name[1024];
00183 snprintf(library_name, sizeof(library_name), "%s.%s.%d", library->GetCategory(), library->GetInstanceName(), library->GetVersion());
00184 strtolower(library_name);
00185
00186 if (this->library_list.find(library_name) != this->library_list.end()) {
00187
00188 #ifdef WIN32
00189
00190 if (strcasecmp(this->library_list[library_name]->GetMainScript(), library->GetMainScript()) == 0) {
00191 #else
00192 if (strcmp(this->library_list[library_name]->GetMainScript(), library->GetMainScript()) == 0) {
00193 #endif
00194 delete library;
00195 return;
00196 }
00197
00198 DEBUG(ai, 1, "Registering two libraries with the same name and version");
00199 DEBUG(ai, 1, " 1: %s", this->library_list[library_name]->GetMainScript());
00200 DEBUG(ai, 1, " 2: %s", library->GetMainScript());
00201 DEBUG(ai, 1, "The first is taking precedence.");
00202
00203 delete library;
00204 return;
00205 }
00206
00207 this->library_list[strdup(library_name)] = library;
00208 }
00209
00210 void AIScanner::RegisterAI(AIInfo *info)
00211 {
00212 char ai_name[1024];
00213 snprintf(ai_name, sizeof(ai_name), "%s.%d", info->GetName(), info->GetVersion());
00214 strtolower(ai_name);
00215
00216
00217 if (strlen(info->GetShortName()) != 4) {
00218 DEBUG(ai, 0, "The AI '%s' returned a string from GetShortName() which is not four characaters. Unable to load the AI.", info->GetName());
00219 delete info;
00220 return;
00221 }
00222
00223 if (this->info_list.find(ai_name) != this->info_list.end()) {
00224
00225 #ifdef WIN32
00226
00227 if (strcasecmp(this->info_list[ai_name]->GetMainScript(), info->GetMainScript()) == 0) {
00228 #else
00229 if (strcmp(this->info_list[ai_name]->GetMainScript(), info->GetMainScript()) == 0) {
00230 #endif
00231 delete info;
00232 return;
00233 }
00234
00235 DEBUG(ai, 1, "Registering two AIs with the same name and version");
00236 DEBUG(ai, 1, " 1: %s", this->info_list[ai_name]->GetMainScript());
00237 DEBUG(ai, 1, " 2: %s", info->GetMainScript());
00238 DEBUG(ai, 1, "The first is taking precedence.");
00239
00240 delete info;
00241 return;
00242 }
00243
00244 this->info_list[strdup(ai_name)] = info;
00245
00246
00247
00248 snprintf(ai_name, sizeof(ai_name), "%s", info->GetName());
00249 strtolower(ai_name);
00250 if (this->info_single_list.find(ai_name) == this->info_single_list.end()) {
00251 this->info_single_list[strdup(ai_name)] = info;
00252 } else if (this->info_single_list[ai_name]->GetVersion() < info->GetVersion()) {
00253 this->info_single_list[ai_name] = info;
00254 }
00255 }
00256
00257 AIInfo *AIScanner::SelectRandomAI() const
00258 {
00259 uint num_random_ais = 0;
00260 for (AIInfoList::const_iterator it = this->info_single_list.begin(); it != this->info_single_list.end(); it++) {
00261 if (it->second->UseAsRandomAI()) num_random_ais++;
00262 }
00263
00264 if (num_random_ais == 0) {
00265 DEBUG(ai, 0, "No suitable AI found, loading 'dummy' AI.");
00266 return this->info_dummy;
00267 }
00268
00269
00270 uint pos;
00271 if (_networking) {
00272 pos = InteractiveRandomRange(num_random_ais);
00273 } else {
00274 pos = RandomRange(num_random_ais);
00275 }
00276
00277
00278 AIInfoList::const_iterator it = this->info_single_list.begin();
00279 while (!it->second->UseAsRandomAI()) it++;
00280 for (; pos > 0; pos--) {
00281 it++;
00282 while (!it->second->UseAsRandomAI()) it++;
00283 }
00284 return (*it).second;
00285 }
00286
00287 AIInfo *AIScanner::FindInfo(const char *nameParam, int versionParam, bool force_exact_match)
00288 {
00289 if (this->info_list.size() == 0) return NULL;
00290 if (nameParam == NULL) return NULL;
00291
00292 char ai_name[1024];
00293 ttd_strlcpy(ai_name, nameParam, sizeof(ai_name));
00294 strtolower(ai_name);
00295
00296 AIInfo *info = NULL;
00297 int version = -1;
00298
00299 if (versionParam == -1) {
00300
00301 if (this->info_single_list.find(ai_name) != this->info_single_list.end()) return this->info_single_list[ai_name];
00302
00303
00304 char *e = strrchr(ai_name, '.');
00305 if (e == NULL) return NULL;
00306 *e = '\0';
00307 e++;
00308 versionParam = atoi(e);
00309
00310 }
00311
00312 if (force_exact_match) {
00313
00314 char ai_name_tmp[1024];
00315 snprintf(ai_name_tmp, sizeof(ai_name_tmp), "%s.%d", ai_name, versionParam);
00316 strtolower(ai_name_tmp);
00317 if (this->info_list.find(ai_name_tmp) != this->info_list.end()) return this->info_list[ai_name_tmp];
00318 }
00319
00320
00321
00322 AIInfoList::iterator it = this->info_list.begin();
00323 for (; it != this->info_list.end(); it++) {
00324 if (strcasecmp(ai_name, (*it).second->GetName()) == 0 && (*it).second->CanLoadFromVersion(versionParam) && (version == -1 || (*it).second->GetVersion() > version)) {
00325 version = (*it).second->GetVersion();
00326 info = (*it).second;
00327 }
00328 }
00329
00330 return info;
00331 }
00332
00333 char *AIScanner::GetAIConsoleList(char *p, const char *last) const
00334 {
00335 p += seprintf(p, last, "List of AIs:\n");
00336 AIInfoList::const_iterator it = this->info_list.begin();
00337 for (; it != this->info_list.end(); it++) {
00338 AIInfo *i = (*it).second;
00339 p += seprintf(p, last, "%10s (v%d): %s\n", i->GetName(), i->GetVersion(), i->GetDescription());
00340 }
00341 p += seprintf(p, last, "\n");
00342
00343 return p;
00344 }
00345
00346 #if defined(ENABLE_NETWORK)
00347 #include "../network/network_content.h"
00348 #include "../3rdparty/md5/md5.h"
00349 #include "../tar_type.h"
00350
00352 struct AIFileChecksumCreator : FileScanner {
00353 byte md5sum[16];
00354
00359 AIFileChecksumCreator()
00360 {
00361 memset(this->md5sum, 0, sizeof(this->md5sum));
00362 }
00363
00364
00365 virtual bool AddFile(const char *filename, size_t basepath_length)
00366 {
00367 Md5 checksum;
00368 uint8 buffer[1024];
00369 size_t len, size;
00370 byte tmp_md5sum[16];
00371
00372
00373 FILE *f = FioFOpenFile(filename, "rb", DATA_DIR, &size);
00374 if (f == NULL) return false;
00375
00376
00377 while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {
00378 size -= len;
00379 checksum.Append(buffer, len);
00380 }
00381 checksum.Finish(tmp_md5sum);
00382
00383 FioFCloseFile(f);
00384
00385
00386 for (uint i = 0; i < sizeof(md5sum); i++) this->md5sum[i] ^= tmp_md5sum[i];
00387
00388 return true;
00389 }
00390 };
00391
00400 static bool IsSameAI(const ContentInfo *ci, bool md5sum, AIFileInfo *info)
00401 {
00402 uint32 id = 0;
00403 const char *str = info->GetShortName();
00404 for (int j = 0; j < 4 && *str != '\0'; j++, str++) id |= *str << (8 * j);
00405
00406 if (id != ci->unique_id) return false;
00407 if (!md5sum) return true;
00408
00409 AIFileChecksumCreator checksum;
00410 char path[MAX_PATH];
00411 strecpy(path, info->GetMainScript(), lastof(path));
00412
00413
00414
00415 *strrchr(path, PATHSEPCHAR) = '\0';
00416 *strrchr(path, PATHSEPCHAR) = '\0';
00417 TarList::iterator iter = _tar_list.find(path);
00418
00419 if (iter != _tar_list.end()) {
00420
00421
00422 TarFileList::iterator tar;
00423 FOR_ALL_TARS(tar) {
00424
00425 if (tar->second.tar_filename != iter->first) continue;
00426
00427
00428 const char *ext = strrchr(tar->first.c_str(), '.');
00429 if (ext == NULL || strcasecmp(ext, ".nut") != 0) continue;
00430
00431
00432 seprintf(path, lastof(path), "%s%c%s", tar->second.tar_filename, PATHSEPCHAR, tar->first.c_str());
00433 checksum.AddFile(path, 0);
00434 }
00435 } else {
00436
00437
00438 path[strlen(path)] = PATHSEPCHAR;
00439 checksum.Scan(".nut", path);
00440 }
00441
00442 return memcmp(ci->md5sum, checksum.md5sum, sizeof(ci->md5sum)) == 0;
00443 }
00444
00451 bool AIScanner::HasAI(const ContentInfo *ci, bool md5sum)
00452 {
00453 switch (ci->type) {
00454 case CONTENT_TYPE_AI:
00455 for (AIInfoList::iterator it = this->info_list.begin(); it != this->info_list.end(); it++) {
00456 if (IsSameAI(ci, md5sum, (*it).second)) return true;
00457 }
00458 return false;
00459
00460 case CONTENT_TYPE_AI_LIBRARY:
00461 for (AILibraryList::iterator it = this->library_list.begin(); it != this->library_list.end(); it++) {
00462 if (IsSameAI(ci, md5sum, (*it).second)) return true;
00463 }
00464 return false;
00465
00466 default:
00467 NOT_REACHED();
00468 }
00469 }
00470
00477 bool AI::HasAI(const ContentInfo *ci, bool md5sum)
00478 {
00479 return AI::ai_scanner->HasAI(ci, md5sum);
00480 }
00481
00482 #endif