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.h"

     9

#include "../fios.h"

    10

#include <sys/types.h>

    11

#include <sys/stat.h>

    12

    13

#include <squirrel.h>

    14

#include "../squirrel.hpp"

    15

#include "../squirrel_helper.hpp"

    16

#include "../squirrel_class.hpp"

    17

#include "../squirrel_std.hpp"

    18

#include "api/ai_controller.hpp"

    19

#include "ai_factory.hpp"

    20

#include "ai_squirrel.hpp"

    21

    22

/* Convert all AI related classes to Squirrel data */

    23

#define DEFINE_SQUIRREL_CLASS

    24

#include "api/ai_base.hpp"

    25

#include "api/ai_cargo.hpp"

    26

#include "api/ai_controller.hpp"

    27

#include "api/ai_company.hpp"

    28

#include "api/ai_execmode.hpp"

    29

#include "api/ai_industry.hpp"

    30

#include "api/ai_map.hpp"

    33

#include "api/ai_settings.hpp"

    34

#include "api/ai_testmode.hpp"

    35

#include "api/ai_town.hpp"

    36

#include "api/ai_transactionmode.hpp"

    37

#undef DEFINE_SQUIRREL_CLASS

    38

    39

static FSquirrel iFSquirrel; ///< Tell the AI-core that we have an AI with which we like to play.

    40

    41

/**

    42

 * Our tiny wrapper between C++ and Squirrel.

    43

 */

    44

class AIFactorySquirrel: public AIFactoryBase {

    45

public:

    46

	Squirrel *engine;

    47

	HSQOBJECT SQ_instance;

    48

	char *script_name;

    49

    50

	~AIFactorySquirrel();

    51

    52

	/* virtual */ const char   *GetAuthor()      { return this->engine->CallStringMethod (this->SQ_instance, "GetAuthor"); }

    53

	/* virtual */ const char   *GetName()        { return this->engine->CallStringMethod (this->SQ_instance, "GetName"); }

    54

	/* virtual */ const char   *GetDescription() { return this->engine->CallStringMethod (this->SQ_instance, "GetDescription"); }

    55

	/* virtual */ int           GetVersion()     { return this->engine->CallIntegerMethod(this->SQ_instance, "GetVersion"); }

    56

	/* virtual */ const char   *GetDate()        { return this->engine->CallStringMethod (this->SQ_instance, "GetDate"); }

    57

	/* virtual */ AIController *CreateInstance();

    58

    59

	/**

    60

	 * Register Squirrel script to the Factory.

    61

	 */

    62

	void RegisterSquirrel()        { this->RegisterFactory(this->GetName()); }

    63

    64

	/**

    65

	 * Check if a method exists in the script.

    66

	 */

    67

	void CheckMethods(AIFactorySquirrel *fbase, SQInteger *res, const char *name);

    68

};

    69

    70

AIFactorySquirrel::~AIFactorySquirrel()

    71

{

    72

	free(this->script_name);

    73

}

    74

    75

void AIFactorySquirrel::CheckMethods(AIFactorySquirrel *fbase, SQInteger *res, const char *name)

    76

{

    77

	if (!fbase->engine->MethodExists(fbase->SQ_instance, name)) {

    78

		char error[1024];

    79

		snprintf(error, sizeof(error), "Missing method '%s' for FactoryClass", name);

    80

		fbase->engine->ThrowError(error);

    81

		*res = SQ_ERROR;

    82

	}

    83

}

    84

    85

SQInteger FSquirrel::FactoryConstructor(HSQUIRRELVM vm)

    86

{

    87

	AIFactorySquirrel *fbase = new AIFactorySquirrel();

    88

	SQInteger res = 0;

    89

    90

	Squirrel::GetInstance(vm, &fbase->SQ_instance);

    91

	fbase->engine = ((FSquirrel *)Squirrel::GetGlobalPointer(vm))->engine;

    92

    93

	/* Check if all needed fields are there */

    94

	fbase->CheckMethods(fbase, &res, "GetAuthor");

    95

	fbase->CheckMethods(fbase, &res, "GetName");

    96

	fbase->CheckMethods(fbase, &res, "GetDescription");

    97

	fbase->CheckMethods(fbase, &res, "GetVersion");

    98

	fbase->CheckMethods(fbase, &res, "GetDate");

    99

	fbase->CheckMethods(fbase, &res, "CreateInstance");

   100

   101

	/* Abort if one method was missing */

   102

	if (res != 0) return res;

   103

   104

	fbase->RegisterSquirrel();

   105

	fbase->script_name = strdup(((FSquirrel *)Squirrel::GetGlobalPointer(vm))->current_script);

   106

   107

	return 0;

   108

}

   109

   110

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

   111

extern bool FiosIsHiddenFile(const struct dirent *ent);

   112

   113

   114

void FSquirrel::ScanDir(const char *dirname)

   115

{

   116

	struct stat sb;

   117

	struct dirent *dirent;

   118

	DIR *dir;

   119

	char d_name[256];

   120

	char script_name[256];

   121

	dir = ttd_opendir(dirname);

   122

	/* Dir not found, so do nothing */

   123

	if (dir == NULL) return;

   124

   125

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

   126

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

   127

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

   128

   129

		/* Found file must be directory, but not '.' or '..' */

   130

		if (FiosIsValidFile("ai", dirent, &sb) && (sb.st_mode & S_IFDIR) &&

   131

				(!FiosIsHiddenFile(dirent) || strncasecmp(d_name, PERSONAL_DIR, strlen(d_name)) == 0) &&

   132

				strcmp(d_name, ".") != 0 && strcmp(d_name, "..") != 0) {

   133

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

   134

			strcpy(script_name, dirname);

   135

			strcat(script_name, PATHSEP);

   136

			strcat(script_name, d_name);

   137

			strcat(script_name, PATHSEP);

   138

			strcat(script_name, "main.nut");

   139

			/* If it exists, load it up */

   140

			if (FileExists(script_name)) {

   141

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

   142

				this->current_script = script_name;

   143

				this->engine->LoadScript(this->current_script);

   144

			}

   145

		}

   146

	}

   147

	closedir(dir);

   148

}

   149

   150

void FSquirrel::Initializer()

   151

{

   152

	this->engine = new Squirrel();

   153

   154

	/* Create the AIFactory class, and bind the constructor */

   155

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

   156

	this->engine->AddMethod("constructor", &FSquirrel::FactoryConstructor, 1, "x");

   157

	this->engine->AddClassEnd();

   158

   159

	/* Set a dummy AIController, so script can load */

   160

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

   161

	this->engine->AddClassEnd();

   162

	/* Mark this class as global pointer */

   163

	this->engine->SetGlobalPointer(this);

   164

   165

	/* Scan the AI dir for scripts */

   166

	this->ScanDir("ai");

   167

}

   168

   169

FSquirrel::~FSquirrel()

   170

{

   171

	delete this->engine;

   172

}

   173

   174

AIController *AIFactorySquirrel::CreateInstance()

   175

{

   176

	const char *class_name = this->engine->CallStringMethod(this->SQ_instance, "CreateInstance");

   177

	AIControllerSquirrel *controller = new AIControllerSquirrel(this->script_name, class_name);

   178

   179

	return controller;

   180

}

   181

   182

void AIControllerSquirrel::RegisterClasses()

   183

{

   184

	/* Ignore AIFactory if we are really starting an AI */

   185

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

   186

	this->engine->AddClassEnd();

   187

   188

	/* Register all classes */

   189

	squirrel_register_std(this->engine);

   190

	SQAIBaseRegister(this->engine);

   191

	SQAICargoRegister(this->engine);

   192

	SQAICompanyRegister(this->engine);

   193

	SQAIControllerRegister(this->engine);

   194

	SQAIExecModeRegister(this->engine);

   195

	SQAIIndustryRegister(this->engine);

   196

	SQAIMapRegister(this->engine);

   198

	SQAIRoadRegister(this->engine);

   199

	SQAISettingsRegister(this->engine);

   200

	SQAITestModeRegister(this->engine);

   201

	SQAITownRegister(this->engine);

   202

	SQAITransactionModeRegister(this->engine);

   203

   204

	this->engine->SetGlobalPointer(this->engine);

   205

}

   206

   207

AIControllerSquirrel::AIControllerSquirrel(const char *script, const char *class_name)

   208

{

   209

	this->engine = new Squirrel();

   210

	this->RegisterClasses();

   211

	this->engine->LoadScript(script);

   212

	/* Create the main-class */

   213

	this->engine->CreateClassInstance(class_name, this, &this->SQ_instance);

   214

	this->engine->CallMethod(this->SQ_instance, "constructor");

   215

}

   216

   217

AIControllerSquirrel::~AIControllerSquirrel()

   218

{

   219

	delete this->engine;

   220

}

   221

   222

/* virtual */ void AIControllerSquirrel::Start()

   223

{

   224

	this->engine->CallMethod(this->SQ_instance, "Start");

   225

}

   226

   227

/* virtual */ void AIControllerSquirrel::Stop()

   228

{

   229

	this->engine->CallMethod(this->SQ_instance, "Stop");

   230

}