1

/* $Id$ */

     2

     3

/** @file squirrel.cpp allows loading squirrel scripts to control an AI */

     4

     5

#include "../stdafx.h"

     6

#include "../debug.h"

     7

#include "../openttd.h"

     8

#include "../string_func.h"

     9

#include "../fileio.h"

    10

#include "../fios.h"

    11

#include "../network/network.h"

    12

#include "../core/random_func.hpp"

    13

#include <sys/types.h>

    14

#include <sys/stat.h>

    15

    16

#include <squirrel.h>

    17

#include "../squirrel.hpp"

    18

#include "ai_info.hpp"

    19

#include "ai_squirrel.hpp"

    21

    22

void AISquirrel::ScanDir(const char *dirname, bool library_dir, char *library_depth)

    23

{

    24

	extern bool FiosIsValidFile(const char *path, const struct dirent *ent, struct stat *sb);

    25

	extern bool FiosIsHiddenFile(const struct dirent *ent);

    26

    27

	struct stat sb;

    28

	struct dirent *dirent;

    29

	DIR *dir;

    30

	char d_name[MAX_PATH];

    31

	char script_name[MAX_PATH];

    32

	dir = ttd_opendir(dirname);

    33

	/* Dir not found, so do nothing */

    34

	if (dir == NULL) return;

    35

    36

	/* Walk all dirs trying to find a dir in which 'main.nut' exists */

    37

	while ((dirent = readdir(dir)) != NULL) {

    38

		ttd_strlcpy(d_name, FS2OTTD(dirent->d_name), sizeof(d_name));

    39

    40

		/* Valid file, not '.' or '..', not hidden */

    41

		if (!FiosIsValidFile(dirname, dirent, &sb)) continue;

    42

		if (strcmp(d_name, ".") == 0 || strcmp(d_name, "..") == 0) continue;

    43

		if (FiosIsHiddenFile(dirent) && strncasecmp(d_name, PERSONAL_DIR, strlen(d_name)) != 0) continue;

    44

    45

		if (sb.st_mode & S_IFDIR) {

    46

			/* Create the full-length script-name */

    47

			ttd_strlcpy(script_name, dirname, sizeof(script_name));

    48

			ttd_strlcat(script_name, d_name, sizeof(script_name));

    49

			ttd_strlcat(script_name, PATHSEP, sizeof(script_name));

    50

    51

			if (library_dir && library_depth == NULL) {

    52

				ScanDir(script_name, library_dir, d_name);

    53

				continue;

    54

			}

    55

		}

    56

		if (sb.st_mode & S_IFREG && !library_dir) {

    57

			char *ext = strrchr(d_name, '.');

    58

			if (ext == NULL || strcasecmp(ext, ".tar") != 0) continue;

    59

    60

			/* Create the full path to the tarfile */

    61

			char tarname[MAX_PATH];

    62

			ttd_strlcpy(tarname, dirname, sizeof(tarname));

    63

			ttd_strlcat(tarname, d_name, sizeof(tarname));

    64

    65

			/* Now the script-name starts with the first dir in the tar */

    66

			assert(FioTarFirstDir(tarname) != NULL);

    67

			ttd_strlcpy(script_name, FioTarFirstDir(tarname), sizeof(script_name));

    68

    69

			/* The name of the AI is the name of the tar minus the .tar */

    70

			*ext = '\0';

    71

		}

    72

    73

		if (!library_dir) {

    74

			/* We look for the file 'info.nut' inside the AI dir.. if it doesn't exists, it isn't an AI */

    75

			ttd_strlcat(script_name, "info.nut", sizeof(script_name));

    76

			if (FioCheckFileExists(script_name, AI_DIR)) {

    77

				char load_script[MAX_PATH];

    78

				ttd_strlcpy(load_script, script_name, sizeof(load_script));

    79

    80

				/* Remove the 'info.nut' part and replace it with 'main.nut' */

    81

				script_name[strlen(script_name) - 8] = '\0';

    82

				ttd_strlcat(script_name, "main.nut", sizeof(script_name));

    83

    84

				DEBUG(ai, 6, "[squirrel] Loading script '%s' for AI handling", load_script);

    85

				this->current_script = script_name;

    86

				this->current_dir = d_name;

    87

				this->engine->LoadScript(load_script);

    88

			}

    89

		} else {

    90

			/* We look for the file 'library.nut' inside the library dir.. */

    91

			ttd_strlcat(script_name, "library.nut", sizeof(script_name));

    92

			if (FioCheckFileExists(script_name, AI_DIR)) {

    93

				char load_script[MAX_PATH];

    94

				char dir_name[MAX_PATH];

    95

				ttd_strlcpy(load_script, script_name, sizeof(load_script));

    96

				ttd_strlcpy(dir_name, library_depth, sizeof(dir_name));

    97

				ttd_strlcat(dir_name, ".", sizeof(dir_name));

    98

				ttd_strlcat(dir_name, d_name, sizeof(dir_name));

    99

   100

				/* Remove the 'library.nut' part and replace it with 'main.nut' */

   101

				script_name[strlen(script_name) - 11] = '\0';

   102

				ttd_strlcat(script_name, "main.nut", sizeof(script_name));

   103

   104

				DEBUG(ai, 6, "[squirrel] Loading script '%s' for Squirrel library", load_script);

   105

				this->current_script = script_name;

   106

				this->current_dir = dir_name;

   107

				this->engine->LoadScript(load_script);

   108

			}

   109

		}

   110

	}

   111

	closedir(dir);

   112

}

   113

   114

void AISquirrel::ScanAIDir()

   115

{

   116

	char buf[MAX_PATH];

   117

	Searchpath sp;

   118

   119

	FOR_ALL_SEARCHPATHS(sp) {

   120

		FioAppendDirectory(buf, MAX_PATH, sp, AI_DIR);

   121

		if (FileExists(buf)) this->ScanDir(buf, false);

   122

		ttd_strlcat(buf, "library" PATHSEP, MAX_PATH);

   123

		if (FileExists(buf)) this->ScanDir(buf, true);

   124

	}

   125

}

   126

   127

void AISquirrel::RescanAIDir()

   128

{

   129

	extern void ScanForTarFiles();

   130

	ScanForTarFiles();

   131

	this->ScanAIDir();

   132

}

   133

   134

AISquirrel::AISquirrel()

   135

{

   136

	this->engine = new Squirrel();

   137

   138

	/* Create the AIInfo class, and add the RegisterAI function */

   139

	this->engine->AddClassBegin("AIInfo");

   140

	this->engine->AddClassEnd();

   141

	this->engine->AddMethod("RegisterAI", &AIInfo::Constructor, 2, "tx");

   142

	/* Create the AILibrary class, and add the RegisterLibrary function */

   143

	this->engine->AddClassBegin("AILibrary");

   144

	this->engine->AddClassEnd();

   145

	this->engine->AddMethod("RegisterLibrary", &AILibrary::Constructor, 2, "tx");

   146

   147

	/* Mark this class as global pointer */

   148

	this->engine->SetGlobalPointer(this);

   149

   150

	/* Scan the AI dir for scripts */

   151

	this->ScanAIDir();

   152

}

   153

   154

AISquirrel::~AISquirrel()

   155

{

   156

	AIInfoList::iterator it = this->info_list.begin();

   157

	for (; it != this->info_list.end(); it++) {

   158

		AIInfo *i = (*it).second;

   159

		delete i;

   160

	}

   161

   162

	delete this->engine;

   163

}

   164

   166

{

   167

	AILibraryList::iterator iter = this->library_list.find(library);

   168

	/* Check if the library exists */

   169

	if (iter == this->library_list.end()) {

   170

		char error[1024];

   171

		snprintf(error, sizeof(error), "couldn't find library '%s'", library);

   172

		sq_throwerror(vm, OTTD2FS(error));

   173

		return false;

   174

	}

   175

   176

	/* Check if the version matches */

   177

	if ((*iter).second->GetVersion() != version) {

   178

		char error[1024];

   179

		snprintf(error, sizeof(error), "this AI is expected library '%s' to be version %d, but it is version %d", library, version, (*iter).second->GetVersion());

   180

		sq_throwerror(vm, OTTD2FS(error));

   181

		return false;

   182

	}

   183

   184

	/* Get the current table/class we belong to */

   185

	HSQOBJECT parent;

   186

	sq_getstackobj(vm, 1, &parent);

   187

   212

	}

   213

   214

	/* Find the real class inside the fake class (like 'sets.Vector') */

   215

	sq_pushroottable(vm);

   216

	sq_pushstring(vm, OTTD2FS(fake_class), -1);

   217

	if (SQ_FAILED(sq_get(vm, -2))) {

   218

		sq_throwerror(vm, _SC("internal error assigning library class"));

   219

		return false;

   220

	}

   221

	sq_pushstring(vm, OTTD2FS((*iter).second->GetInstanceName()), -1);

   222

	if (SQ_FAILED(sq_get(vm, -2))) {

   223

		char error[1024];

   224

		snprintf(error, sizeof(error), "unable to find class '%s' in the library '%s'", (*iter).second->GetInstanceName(), library);

   225

		sq_throwerror(vm, OTTD2FS(error));

   226

		return false;

   227

	}

   228

	HSQOBJECT obj;

   229

	sq_getstackobj(vm, -1, &obj);

   230

	sq_pop(vm, 3);

   231

   232

	if (StrEmpty(class_name)) {

   233

		sq_pushobject(vm, obj);

   234

		return true;

   235

	}

   236

   237

	/* Now link the name the user wanted to our 'fake' class */

   238

	sq_pushobject(vm, parent);

   239

	sq_pushstring(vm, OTTD2FS(class_name), -1);

   240

	sq_pushobject(vm, obj);

   241

	sq_newclass(vm, SQTrue);

   242

	sq_newslot(vm, -3, SQFalse);

   243

	sq_pop(vm, 1);

   244

   245

	sq_pushobject(vm, obj);

   246

	return true;

   247

}

   248

   249

void AISquirrel::RegisterLibrary(AILibrary *library)

   250

{

   251

	const char *ai_name = library->GetDirName();

   252

   253

	/* Check if we register twice; than the first always wins */

   254

	if (this->library_list.find(ai_name) != this->library_list.end()) {

   255

		/* In case they are not the same dir, give a warning */

   256

		if (strcasecmp(library->GetScriptName(), this->library_list[ai_name]->GetScriptName()) != 0) {

   257

			DEBUG(ai, 0, "Registering two Libraries with the same name");

   258

			DEBUG(ai, 0, "  1: %s", this->library_list[ai_name]->GetScriptName());

   259

			DEBUG(ai, 0, "  2: %s", library->GetScriptName());

   260

			DEBUG(ai, 0, "The first is taking precedence");

   261

		}

   262

		/* Delete the new AILibrary, as we will be using the old one */

   263

		delete library;

   264

		return;

   265

	}

   266

	this->library_list[ai_name] = library;

   267

}

   268

   269

void AISquirrel::RegisterAI(AIInfo *info)

   270

{

   271

	const char *ai_name = info->GetDirName();

   272

   273

	/* Check if we register twice; than the first always wins */

   274

	if (this->info_list.find(ai_name) != this->info_list.end()) {

   275

		/* In case they are not the same dir, give a warning */

   276

		if (strcasecmp(info->GetScriptName(), this->info_list[ai_name]->GetScriptName()) != 0) {

   277

			DEBUG(ai, 0, "Registering two AIs with the same name");

   278

			DEBUG(ai, 0, "  1: %s", this->info_list[ai_name]->GetScriptName());

   279

			DEBUG(ai, 0, "  2: %s", info->GetScriptName());

   280

			DEBUG(ai, 0, "The first is taking precedence");

   281

		}

   282

		/* Delete the new AIInfo, as we will be using the old one */

   283

		delete info;

   284

		return;

   285

	}

   286

	this->info_list[ai_name] = info;

   287

}

   288

   289

void AISquirrel::UnregisterAI(AIInfo *info)

   290

{

   291

	this->info_list.erase(info->GetDirName());

   292

}

   293

   294

AIInfo *AISquirrel::SelectRandomAI()

   295

{

   296

	if (this->info_list.size() == 0) return NULL;

   297

   298

	/* Find a random AI */

   299

	uint pos;

   300

	if (_networking) pos = InteractiveRandomRange(this->info_list.size());

   301

	else             pos =            RandomRange(this->info_list.size());

   302

   303

	/* Find the Nth item from the array */

   304

	AIInfoList::iterator it = this->info_list.begin();

   305

	for (; pos > 0; pos--) it++;

   306

	AIInfoList::iterator first_it = it;

   307

	AIInfo *i = (*it).second;

   308

   309

	if (!i->AllowStartup()) {

   310

		/* We can't start this AI, try to find the next best */

   311

		do {

   312

			it++;

   313

			if (it == this->info_list.end()) it = this->info_list.begin();

   314

			/* Back at the beginning? We can't start an AI. */

   315

			if (first_it == it) return NULL;

   316

   317

			i = (*it).second;

   318

		} while (!i->AllowStartup());

   319

	}

   320

	return i;

   321

}

   322

   323

AIInfo *AISquirrel::SelectAI(const char *name)

   324

{

   325

	if (this->info_list.size() == 0) return NULL;

   326

   327

	AIInfoList::iterator it = this->info_list.begin();

   328

	for (; it != this->info_list.end(); it++) {

   329

		AIInfo *i = (*it).second;

   330

   331

		if (strcasecmp(name, (*it).first) == 0 && i->AllowStartup()) {

   332

			return i;

   333

		}

   334

	}

   335

   336

	return NULL;

   337

}

   338

   339

char *AISquirrel::GetAIConsoleList(char *p, const char *last)

   340

{

   341

	p += snprintf(p, last - p, "List of AIs:\n");

   342

	AIInfoList::iterator it = this->info_list.begin();

   343

	for (; it != this->info_list.end(); it++) {

   344

		AIInfo *i = (*it).second;

   345

		if (!i->AllowStartup()) continue;

   346

		p += snprintf(p, last - p, "%10s: %s\n", (*it).first, i->GetDescription());

   347

	}

   348

	p += snprintf(p, last - p, "\n");

   349

   350

	return p;

   351

}