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

 * Note: this line a marker in squirrel_export.sh. Do not change! */

    24

#include "api/ai_abstractlist.hpp.sq"

    25

#include "api/ai_accounting.hpp.sq"

    26

#include "api/ai_base.hpp.sq"

    27

#include "api/ai_cargo.hpp.sq"

    28

#include "api/ai_company.hpp.sq"

    29

#include "api/ai_controller.hpp.sq"

    30

#include "api/ai_execmode.hpp.sq"

    31

#include "api/ai_industry.hpp.sq"

    32

#include "api/ai_list.hpp.sq"

    33

#include "api/ai_map.hpp.sq"

    34

#include "api/ai_order.hpp.sq"

    35

#include "api/ai_road.hpp.sq"

    36

#include "api/ai_settings.hpp.sq"

    37

#include "api/ai_sign.hpp.sq"

    38

#include "api/ai_testmode.hpp.sq"

    39

#include "api/ai_tilelist.hpp.sq"

    40

#include "api/ai_tilelist_valuator.hpp.sq"

    41

#include "api/ai_town.hpp.sq"

    42

#include "api/ai_townlist.hpp.sq"

    43

#include "api/ai_townlist_valuator.hpp.sq"

    44

#include "api/ai_transactionmode.hpp.sq"

    45

#include "api/ai_vehicle.hpp.sq"

    46

    47

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

    48

    49

/**

    50

 * Our tiny wrapper between C++ and Squirrel.

    51

 */

    52

class AIFactorySquirrel: public AIFactoryBase {

    53

public:

    54

	Squirrel *engine;

    55

	HSQOBJECT SQ_instance;

    56

	char *script_name;

    57

    58

	~AIFactorySquirrel();

    59

    60

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

    61

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

    62

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

    63

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

    64

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

    65

	/* virtual */ AIController *CreateInstance();

    66

    67

	/**

    68

	 * Register Squirrel script to the Factory.

    69

	 */

    70

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

    71

    72

	/**

    73

	 * Check if a method exists in the script.

    74

	 */

    75

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

    76

};

    77

    78

AIFactorySquirrel::~AIFactorySquirrel()

    79

{

    80

	free(this->script_name);

    81

}

    82

    83

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

    84

{

    85

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

    86

		char error[1024];

    87

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

    88

		fbase->engine->ThrowError(error);

    89

		*res = SQ_ERROR;

    90

	}

    91

}

    92

    93

SQInteger FSquirrel::FactoryConstructor(HSQUIRRELVM vm)

    94

{

    95

	AIFactorySquirrel *fbase = new AIFactorySquirrel();

    96

	SQInteger res = 0;

    97

    98

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

    99

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

   100

   101

	/* Check if all needed fields are there */

   102

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

   103

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

   104

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

   105

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

   106

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

   107

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

   108

   109

	/* Abort if one method was missing */

   110

	if (res != 0) return res;

   111

   112

	fbase->RegisterSquirrel();

   113

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

   114

   115

	return 0;

   116

}

   117

   118

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

   119

extern bool FiosIsHiddenFile(const struct dirent *ent);

   120

   121

   122

void FSquirrel::ScanDir(const char *dirname)

   123

{

   124

	struct stat sb;

   125

	struct dirent *dirent;

   126

	DIR *dir;

   127

	char d_name[256];

   128

	char script_name[256];

   129

	dir = ttd_opendir(dirname);

   130

	/* Dir not found, so do nothing */

   131

	if (dir == NULL) return;

   132

   133

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

   134

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

   135

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

   136

   137

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

   138

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

   139

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

   140

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

   141

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

   142

			strcpy(script_name, dirname);

   143

			strcat(script_name, PATHSEP);

   144

			strcat(script_name, d_name);

   145

			strcat(script_name, PATHSEP);

   146

			strcat(script_name, "main.nut");

   147

			/* If it exists, load it up */

   148

			if (FileExists(script_name)) {

   149

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

   150

				this->current_script = script_name;

   151

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

   152

			}

   153

		}

   154

	}

   155

	closedir(dir);

   156

}

   157

   158

void FSquirrel::Initializer()

   159

{

   160

	this->engine = new Squirrel();

   161

   162

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

   163

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

   164

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

   165

	this->engine->AddClassEnd();

   166

   167

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

   168

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

   169

	this->engine->AddClassEnd();

   170

	/* Mark this class as global pointer */

   171

	this->engine->SetGlobalPointer(this);

   172

   173

	/* Scan the AI dir for scripts */

   174

	this->ScanDir("ai");

   175

}

   176

   177

FSquirrel::~FSquirrel()

   178

{

   179

	delete this->engine;

   180

}

   181

   182

AIController *AIFactorySquirrel::CreateInstance()

   183

{

   184

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

   185

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

   186

   187

	return controller;

   188

}

   189

   190

void AIControllerSquirrel::RegisterClasses()

   191

{

   192

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

   193

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

   194

	this->engine->AddClassEnd();

   195

   196

	/* Register all classes */

   197

	squirrel_register_std(this->engine);

   198

	SQAIAbstractListRegister(this->engine);

   199

	SQAIAccountingRegister(this->engine);

   200

	SQAIBaseRegister(this->engine);

   201

	SQAICargoRegister(this->engine);

   202

	SQAICompanyRegister(this->engine);

   203

	SQAIControllerRegister(this->engine);

   204

	SQAIExecModeRegister(this->engine);

   205

	SQAIIndustryRegister(this->engine);

   206

	SQAIListRegister(this->engine);

   207

	SQAIMapRegister(this->engine);

   208

	SQAIOrderRegister(this->engine);

   209

	SQAIRoadRegister(this->engine);

   210

	SQAISettingsRegister(this->engine);

   211

	SQAISignRegister(this->engine);

   212

	SQAITestModeRegister(this->engine);

   213

	SQAITileListBuildableRegister(this->engine);

   214

	SQAITileListCargoAcceptanceRegister(this->engine);

   215

	SQAITileListNeighbourRoadRegister(this->engine);

   216

	SQAITileListRegister(this->engine);

   217

	SQAITileListRoadTileRegister(this->engine);

   219

	SQAITownListGetLocationRegister(this->engine);

   220

	SQAITownListGetPopulationRegister(this->engine);

   221

	SQAITownListRegister(this->engine);

   222

	SQAITownRegister(this->engine);

   223

	SQAITransactionModeRegister(this->engine);

   224

	SQAIVehicleRegister(this->engine);

   225

   226

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

   227

}

   228

   229

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

   230

{

   231

	this->engine = new Squirrel();

   232

	this->RegisterClasses();

   233

	this->engine->LoadScript(script);

   234

	/* Create the main-class */

   235

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

   236

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

   237

}

   238

   239

AIControllerSquirrel::~AIControllerSquirrel()

   240

{

   241

	delete this->engine;

   242

}

   243

   244

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

   245

{

   246

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

   247

}

   248

   249

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

   250

{

   251

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

   252

}