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