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 <sys/types.h>

    12

#include <sys/stat.h>

    13

    14

#include <squirrel.h>

    15

#include "../squirrel.hpp"

    16

#include "../squirrel_helper.hpp"

    17

#include "../squirrel_class.hpp"

    18

#include "../squirrel_std.hpp"

    19

#include "api/ai_controller.hpp"

    20

#include "ai_factory.hpp"

    21

#include "ai_squirrel.hpp"

    22

    23

/* Convert all AI related classes to Squirrel data.

    24

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

    25

#include "api/ai_abstractlist.hpp.sq"

    26

#include "api/ai_accounting.hpp.sq"

    27

#include "api/ai_airport.hpp.sq"

    28

#include "api/ai_base.hpp.sq"

    29

#include "api/ai_cargo.hpp.sq"

    30

#include "api/ai_cargolist.hpp.sq"

    32

#include "api/ai_company.hpp.sq"

    33

#include "api/ai_controller.hpp.sq"

    34

#include "api/ai_engine.hpp.sq"

    35

#include "api/ai_enginelist.hpp.sq"

    36

#include "api/ai_enginelist_valuator.hpp.sq"

    37

#include "api/ai_event.hpp.sq"

    38

#include "api/ai_event_types.hpp.sq"

    39

#include "api/ai_execmode.hpp.sq"

    40

#include "api/ai_industry.hpp.sq"

    41

#include "api/ai_industrylist.hpp.sq"

    42

#include "api/ai_industrylist_valuator.hpp.sq"

    43

#include "api/ai_list.hpp.sq"

    44

#include "api/ai_list_valuator.hpp.sq"

    45

#include "api/ai_map.hpp.sq"

    46

#include "api/ai_marine.hpp.sq"

    47

#include "api/ai_order.hpp.sq"

    48

#include "api/ai_pathfinder.hpp.sq"

    49

#include "api/ai_pathfinder_stupid.hpp.sq"

    50

#include "api/ai_road.hpp.sq"

    51

#include "api/ai_settings.hpp.sq"

    52

#include "api/ai_sign.hpp.sq"

    53

#include "api/ai_station.hpp.sq"

    54

#include "api/ai_stationlist.hpp.sq"

    55

#include "api/ai_stationlist_valuator.hpp.sq"

    56

#include "api/ai_testmode.hpp.sq"

    57

#include "api/ai_tile.hpp.sq"

    58

#include "api/ai_tilelist.hpp.sq"

    59

#include "api/ai_tilelist_valuator.hpp.sq"

    60

#include "api/ai_town.hpp.sq"

    61

#include "api/ai_townlist.hpp.sq"

    62

#include "api/ai_townlist_valuator.hpp.sq"

    63

#include "api/ai_transactionmode.hpp.sq"

    64

#include "api/ai_vehicle.hpp.sq"

    65

#include "api/ai_vehiclelist.hpp.sq"

    66

#include "api/ai_vehiclelist_valuator.hpp.sq"

    67

    68

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

    69

    70

/**

    71

 * Our tiny wrapper between C++ and Squirrel.

    72

 */

    73

class AIFactorySquirrel: public AIFactoryBase {

    74

public:

    75

	Squirrel *engine;

    76

	HSQOBJECT SQ_instance;

    77

	char *script_name;

    78

    79

	~AIFactorySquirrel();

    80

    81

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

    82

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

    83

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

    84

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

    85

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

    86

	/* virtual */ AIController *CreateInstance();

    87

    88

	/**

    89

	 * Register Squirrel script to the Factory.

    90

	 */

    91

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

    92

    93

	/**

    94

	 * Check if a method exists in the script.

    95

	 */

    96

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

    97

};

    98

    99

AIFactorySquirrel::~AIFactorySquirrel()

   100

{

   101

	free(this->script_name);

   102

}

   103

   104

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

   105

{

   106

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

   107

		char error[1024];

   108

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

   109

		fbase->engine->ThrowError(error);

   110

		*res = SQ_ERROR;

   111

	}

   112

}

   113

   114

SQInteger FSquirrel::FactoryConstructor(HSQUIRRELVM vm)

   115

{

   116

	AIFactorySquirrel *fbase = new AIFactorySquirrel();

   117

	SQInteger res = 0;

   118

   119

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

   120

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

   121

   122

	/* Check if all needed fields are there */

   123

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

   124

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

   125

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

   126

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

   127

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

   128

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

   129

   130

	/* Abort if one method was missing */

   131

	if (res != 0) return res;

   132

   133

	fbase->RegisterSquirrel();

   134

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

   135

   136

	return 0;

   137

}

   138

   139

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

   140

extern bool FiosIsHiddenFile(const struct dirent *ent);

   141

   142

   143

void FSquirrel::ScanDir(const char *dirname)

   144

{

   145

	struct stat sb;

   146

	struct dirent *dirent;

   147

	DIR *dir;

   148

	char d_name[MAX_PATH];

   149

	char script_name[MAX_PATH];

   150

	dir = ttd_opendir(dirname);

   151

	/* Dir not found, so do nothing */

   152

	if (dir == NULL) return;

   153

   154

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

   155

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

   156

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

   157

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

			/* If it exists, load it up */

   169

			if (FileExists(script_name)) {

   170

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

   171

				this->current_script = script_name;

   172

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

   173

			}

   174

		}

   175

	}

   176

	closedir(dir);

   177

}

   178

   179

void FSquirrel::Initializer()

   180

{

   181

	this->engine = new Squirrel();

   182

   183

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

   184

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

   185

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

   186

	this->engine->AddClassEnd();

   187

   188

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

   189

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

   190

	this->engine->AddClassEnd();

   191

	/* Mark this class as global pointer */

   192

	this->engine->SetGlobalPointer(this);

   193

   194

	/* Scan the AI dir for scripts */

   195

	this->ScanDir("ai");

   196

}

   197

   198

FSquirrel::~FSquirrel()

   199

{

   200

	delete this->engine;

   201

}

   202

   203

AIController *AIFactorySquirrel::CreateInstance()

   204

{

   205

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

   206

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

   207

   208

	return controller;

   209

}

   210

   211

void AIControllerSquirrel::RegisterClasses()

   212

{

   213

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

   214

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

   215

	this->engine->AddClassEnd();

   216

   217

	/* Register all classes */

   218

	squirrel_register_std(this->engine);

   219

	SQAIAbstractList_Register(this->engine);

   220

	SQAIAccounting_Register(this->engine);

   221

	SQAIAirport_Register(this->engine);

   222

	SQAIBase_Register(this->engine);

   223

	SQAICargo_Register(this->engine);

   224

	SQAICargoList_Register(this->engine);

   227

	SQAICompany_Register(this->engine);

   228

	SQAIController_Register(this->engine);

   229

	SQAIEngine_Register(this->engine);

   230

	SQAIEngineList_Register(this->engine);

   231

	SQAIEngineList_vCapacity_Register(this->engine);

   232

	SQAIEngineList_vCargoType_Register(this->engine);

   233

	SQAIEngineList_vMaxSpeed_Register(this->engine);

   234

	SQAIEngineList_vPrice_Register(this->engine);

   235

	SQAIEngineList_vReliability_Register(this->engine);

   236

	SQAIEvent_Register(this->engine);

   237

	SQAIEventController_Register(this->engine);

   238

	SQAIEventTest_Register(this->engine);

   239

	SQAIEventVehicleCrash_Register(this->engine);

   240

	SQAIExecMode_Register(this->engine);

   241

	SQAIIndustry_Register(this->engine);

   242

	SQAIIndustryList_Register(this->engine);

   243

	SQAIIndustryList_CargoAccepting_Register(this->engine);

   244

	SQAIIndustryList_CargoProducing_Register(this->engine);

   245

	SQAIIndustryList_vCargoAccepted_Register(this->engine);

   246

	SQAIIndustryList_vDistanceManhattanToTile_Register(this->engine);

   247

	SQAIIndustryList_vDistanceSquareToTile_Register(this->engine);

   248

	SQAIIndustryList_vLocation_Register(this->engine);

   249

	SQAIIndustryList_vProduction_Register(this->engine);

   250

	SQAIList_Register(this->engine);

   251

	SQAIList_vRandomize_Register(this->engine);

   252

	SQAIMap_Register(this->engine);

   253

	SQAIMarine_Register(this->engine);

   254

	SQAIOrder_Register(this->engine);

   255

	SQAIPathFinder_Register(this->engine);

   256

	SQAIPathFinderStupid_Register(this->engine);

   257

	SQAIRoad_Register(this->engine);

   258

	SQAISettings_Register(this->engine);

   259

	SQAISign_Register(this->engine);

   260

	SQAIStation_Register(this->engine);

   261

	SQAIStationList_Register(this->engine);

   262

	SQAIStationList_Vehicle_Register(this->engine);

   263

	SQAIStationList_vCargoRating_Register(this->engine);

   264

	SQAIStationList_vCargoWaiting_Register(this->engine);

   265

	SQAIStationList_vDistanceManhattanToTile_Register(this->engine);

   266

	SQAIStationList_vDistanceSquareToTile_Register(this->engine);

   267

	SQAIStationList_vLocation_Register(this->engine);

   268

	SQAITestMode_Register(this->engine);

   269

	SQAITile_Register(this->engine);

   270

	SQAITileList_Register(this->engine);

   271

	SQAITileList_IndustryAccepting_Register(this->engine);

   272

	SQAITileList_IndustryProducing_Register(this->engine);

   273

	SQAITileList_vBuildable_Register(this->engine);

   274

	SQAITileList_vBuildableRectangle_Register(this->engine);

   275

	SQAITileList_vCargoAcceptance_Register(this->engine);

   276

	SQAITileList_vCargoProduction_Register(this->engine);

   277

	SQAITileList_vDistanceManhattanToTile_Register(this->engine);

   278

	SQAITileList_vDistanceSquareToTile_Register(this->engine);

   279

	SQAITileList_vHeight_Register(this->engine);

   280

	SQAITileList_vNeighbourRoadCount_Register(this->engine);

   281

	SQAITileList_vRoadTile_Register(this->engine);

   282

	SQAITileList_vSlope_Register(this->engine);

   283

	SQAITileList_vWater_Register(this->engine);

   284

	SQAITown_Register(this->engine);

   285

	SQAITownList_Register(this->engine);

   286

	SQAITownList_vDistanceManhattanToTile_Register(this->engine);

   287

	SQAITownList_vDistanceSquareToTile_Register(this->engine);

   288

	SQAITownList_vLocation_Register(this->engine);

   289

	SQAITownList_vPopulation_Register(this->engine);

   290

	SQAITransactionMode_Register(this->engine);

   291

	SQAIVehicle_Register(this->engine);

   292

	SQAIVehicleList_Register(this->engine);

   293

	SQAIVehicleList_Station_Register(this->engine);

   294

	SQAIVehicleList_vAge_Register(this->engine);

   295

	SQAIVehicleList_vAgeLeft_Register(this->engine);

   296

	SQAIVehicleList_vEngineType_Register(this->engine);

   297

	SQAIVehicleList_vLocation_Register(this->engine);

   298

	SQAIVehicleList_vMaxAge_Register(this->engine);

   299

	SQAIVehicleList_vProfitLastYear_Register(this->engine);

   300

	SQAIVehicleList_vProfitThisYear_Register(this->engine);

   301

	SQAIVehicleList_vUnitNumber_Register(this->engine);

   302

	SQAIVehicleList_vVehicleType_Register(this->engine);

   303

   304

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

   305

}

   306

   307

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

   308

{

   309

	this->engine = new Squirrel();

   310

	this->engine->SetPrintFunction(&AIControllerSquirrel::PrintFunc);

   311

	this->RegisterClasses();

   312

	this->engine->LoadScript(script);

   313

	/* Create the main-class */

   314

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

   315

	if (this->engine->MethodExists(this->SQ_instance, "constructor"))

   316

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

   317

}

   318

   319

AIControllerSquirrel::~AIControllerSquirrel()

   320

{

   321

	delete this->engine;

   322

}

   323

   324

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

   325

{

   326

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

   327

}

   328

   329

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

   330

{

   331

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

   332

}