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"

    20

    21

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

    22

{

    23

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

    24

	extern bool FiosIsHiddenFile(const struct dirent *ent);

    25

    26

	struct stat sb;

    27

	struct dirent *dirent;

    28

	DIR *dir;

    29

	char d_name[MAX_PATH];

    30

	char script_name[MAX_PATH];

    31

	dir = ttd_opendir(dirname);

    32

	/* Dir not found, so do nothing */

    33

	if (dir == NULL) return;

    34

    35

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

    36

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

    37

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

    38

    39

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

    40

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

    41

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

    42

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

    43

    44

		if (sb.st_mode & S_IFDIR) {

    45

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

    46

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

    47

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

    48

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

    49

    50

			if (library_dir && library_depth == NULL) {

    51

				ScanDir(script_name, library_dir, d_name);

    52

				continue;

    53

			}

    54

		}

    56

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

    57

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

    58

    59

			/* Create the full path to the tarfile */

    60

			char tarname[MAX_PATH];

    61

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

    62

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

    63

    64

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

    65

			assert(FioTarFirstDir(tarname) != NULL);

    66

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

    67

    68

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

    69

			*ext = '\0';

    70

		}

    71

    72

		if (!library_dir) {

    73

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

    74

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

    75

			if (FioCheckFileExists(script_name, AI_DIR)) {

    76

				char load_script[MAX_PATH];

    77

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

    78

    79

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

    80

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

    81

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

    82

    83

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

    84

				this->current_script = script_name;

    85

				this->current_dir = d_name;

    86

				this->engine->LoadScript(load_script);

    87

			}

    88

		} else {

    89

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

    90

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

    91

			if (FioCheckFileExists(script_name, AI_DIR)) {

    92

				char load_script[MAX_PATH];

    93

				char dir_name[MAX_PATH];

    94

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

    95

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

    96

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

    97

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

    98

    99

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

   100

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

   101

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

   102

   103

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

   104

				this->current_script = script_name;

   105

				this->current_dir = dir_name;

   106

				this->engine->LoadScript(load_script);

   107

			}

   108

		}

   109

	}

   110

	closedir(dir);

   111

}

   112

   113

void AISquirrel::ScanAIDir()

   114

{

   115

	char buf[MAX_PATH];

   116

	Searchpath sp;

   117

   118

	FOR_ALL_SEARCHPATHS(sp) {

   119

		FioAppendDirectory(buf, MAX_PATH, sp, AI_DIR);

   120

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

   121

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

   122

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

   123

	}

   124

}

   125

   126

void AISquirrel::RescanAIDir()

   127

{

   128

	extern void ScanForTarFiles();

   129

	ScanForTarFiles();

   130

	this->ScanAIDir();

   131

}

   132

   133

AISquirrel::AISquirrel()

   134

{

   135

	this->library_instance_count = 0;

   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

   165

bool AISquirrel::ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm)

   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

	/* Create a fake internal name */

   185

	char fake_class[1024];

   186

	snprintf(fake_class, sizeof(fake_class), "_internalNA%d", ++this->library_instance_count);

   187

   188

	/* Load the library in a 'fake' namespace, so we can link it to the name the user requested */

   189

	sq_pushroottable(vm);

   190

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

   191

	sq_newclass(vm, SQFalse);

   192

	/* Load the library */

   193

	if (!Squirrel::LoadScript(vm, (*iter).second->GetScriptName(), false)) {

   194

		char error[1024];

   195

		snprintf(error, sizeof(error), "there was a compile error when importing '%s'", library);

   196

		sq_throwerror(vm, OTTD2FS(error));

   197

		return false;

   198

	}

   199

	/* Create the fake class */

   200

	sq_newslot(vm, -3, SQFalse);

   201

	sq_pop(vm, 1);

   202

   203

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

   204

	sq_pushroottable(vm);

   205

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

   206

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

   207

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

   208

		return false;

   209

	}

   210

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

   211

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

   212

		char error[1024];

   213

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

   214

		sq_throwerror(vm, OTTD2FS(error));

   215

		return false;

   216

	}

   217

	HSQOBJECT obj;

   218

	sq_getstackobj(vm, -1, &obj);

   219

	sq_pop(vm, 3);

   220

   221

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

   222

	sq_pushroottable(vm);

   223

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

   224

	sq_pushobject(vm, obj);

   225

	sq_newclass(vm, SQTrue);

   226

	sq_newslot(vm, -3, SQFalse);

   227

	sq_pop(vm, 1);

   228

   229

	return true;

   230

}

   231

   232

void AISquirrel::RegisterLibrary(AILibrary *library)

   233

{

   234

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

   235

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

		}

   245

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

   246

		delete library;

   247

		return;

   248

	}

   249

	this->library_list[ai_name] = library;

   250

}

   251

   252

void AISquirrel::RegisterAI(AIInfo *info)

   253

{

   254

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

   255

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

		}

   265

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

   266

		delete info;

   267

		return;

   268

	}

   269

	this->info_list[ai_name] = info;

   270

}

   271

   272

void AISquirrel::UnregisterAI(AIInfo *info)

   273

{

   274

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

   275

}

   276

   277

AIInfo *AISquirrel::SelectRandomAI()

   278

{

   279

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

   280

   281

	/* Find a random AI */

   282

	uint pos;

   283

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

   284

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

   285

   286

	/* Find the Nth item from the array */

   287

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

   288

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

   289

	AIInfoList::iterator first_it = it;

   290

	AIInfo *i = (*it).second;

   291

   292

	if (!i->AllowStartup()) {

   293

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

   294

		do {

   295

			it++;

   296

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

   297

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

   298

			if (first_it == it) return NULL;

   299

   300

			i = (*it).second;

   301

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

   302

	}

   303

	return i;

   304

}

   305

   306

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

   307

{

   308

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

   309

   310

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

   311

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

   312

		AIInfo *i = (*it).second;

   313

   314

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

   315

			return i;

   316

		}

   317

	}

   318

   319

	return NULL;

   320

}

   321

   322

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

   323

{

   324

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

   325

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

   326

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

   327

		AIInfo *i = (*it).second;

   328

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

   329

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

   330

	}

   331

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

   332

   333

	return p;

   334

}