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

		}

    55

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

    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

   192

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

   193

	sq_pushroottable(vm);

   194

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

   195

	sq_newclass(vm, SQFalse);

   196

	/* Load the library */

   197

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

   198

		char error[1024];

   199

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

   200

		sq_throwerror(vm, OTTD2FS(error));

   201

		return false;

   202

	}

   203

	/* Create the fake class */

   204

	sq_newslot(vm, -3, SQFalse);

   205

	sq_pop(vm, 1);

   206

   207

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

   208

	sq_pushroottable(vm);

   209

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

   210

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

   211

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

   212

		return false;

   213

	}

   214

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

   215

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

   216

		char error[1024];

   217

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

   218

		sq_throwerror(vm, OTTD2FS(error));

   219

		return false;

   220

	}

   221

	HSQOBJECT obj;

   222

	sq_getstackobj(vm, -1, &obj);

   223

	sq_pop(vm, 3);

   224

   230

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

   232

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

   233

	sq_pushobject(vm, obj);

   234

	sq_newclass(vm, SQTrue);

   235

	sq_newslot(vm, -3, SQFalse);

   236

	sq_pop(vm, 1);

   237

   239

	return true;

   240

}

   241

   242

void AISquirrel::RegisterLibrary(AILibrary *library)

   243

{

   244

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

   245

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

		}

   255

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

   256

		delete library;

   257

		return;

   258

	}

   259

	this->library_list[ai_name] = library;

   260

}

   261

   262

void AISquirrel::RegisterAI(AIInfo *info)

   263

{

   264

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

   265

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

		}

   275

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

   276

		delete info;

   277

		return;

   278

	}

   279

	this->info_list[ai_name] = info;

   280

}

   281

   282

void AISquirrel::UnregisterAI(AIInfo *info)

   283

{

   284

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

   285

}

   286

   287

AIInfo *AISquirrel::SelectRandomAI()

   288

{

   289

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

   290

   291

	/* Find a random AI */

   292

	uint pos;

   293

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

   294

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

   295

   296

	/* Find the Nth item from the array */

   297

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

   298

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

   299

	AIInfoList::iterator first_it = it;

   300

	AIInfo *i = (*it).second;

   301

   302

	if (!i->AllowStartup()) {

   303

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

   304

		do {

   305

			it++;

   306

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

   307

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

   308

			if (first_it == it) return NULL;

   309

   310

			i = (*it).second;

   311

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

   312

	}

   313

	return i;

   314

}

   315

   316

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

   317

{

   318

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

   319

   320

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

   321

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

   322

		AIInfo *i = (*it).second;

   323

   324

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

   325

			return i;

   326

		}

   327

	}

   328

   329

	return NULL;

   330

}

   331

   332

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

   333

{

   334

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

   335

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

   336

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

   337

		AIInfo *i = (*it).second;

   338

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

   339

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

   340

	}

   341

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

   342

   343

	return p;

   344

}