1

/* $Id$ */

     2

     3

/** @file ai_controller.cpp Implementation of AIControler. */

     4

     5

#include "../../stdafx.h"

     6

#include "../../openttd.h"

     7

#include "../../player_func.h"

     8

#include "../../core/alloc_func.hpp"

     9

#include "../../string_func.h"

    10

#include "table/strings.h"

    11

    12

#include <squirrel.h>

    13

#include "../../squirrel.hpp"

    14

#include "../../squirrel_helper.hpp"

    15

#include "../../squirrel_class.hpp"

    16

#include "../../squirrel_std.hpp"

    17

#include "ai_controller.hpp"

    18

#include "../ai_threads.h"

    19

#include "../ai_info.hpp"

    20

    21

/* Convert all AI related classes to Squirrel data.

    22

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

    23

#include "ai_abstractlist.hpp.sq"

    24

#include "ai_accounting.hpp.sq"

    25

#include "ai_airport.hpp.sq"

    26

#include "ai_base.hpp.sq"

    27

#include "ai_bridge.hpp.sq"

    28

#include "ai_bridgelist.hpp.sq"

    29

#include "ai_cargo.hpp.sq"

    30

#include "ai_cargolist.hpp.sq"

    31

#include "ai_company.hpp.sq"

    32

#include "ai_controller.hpp.sq"

    33

#include "ai_date.hpp.sq"

    34

#include "ai_depotlist.hpp.sq"

    35

#include "ai_engine.hpp.sq"

    36

#include "ai_enginelist.hpp.sq"

    37

#include "ai_error.hpp.sq"

    38

#include "ai_event.hpp.sq"

    39

#include "ai_event_types.hpp.sq"

    40

#include "ai_execmode.hpp.sq"

    41

#include "ai_gamesettings.hpp.sq"

    42

#include "ai_group.hpp.sq"

    43

#include "ai_grouplist.hpp.sq"

    44

#include "ai_industry.hpp.sq"

    45

#include "ai_industrylist.hpp.sq"

    46

#include "ai_list.hpp.sq"

    47

#include "ai_log.hpp.sq"

    48

#include "ai_map.hpp.sq"

    49

#include "ai_marine.hpp.sq"

    50

#include "ai_order.hpp.sq"

    51

#include "ai_road.hpp.sq"

    52

#include "ai_sign.hpp.sq"

    53

#include "ai_station.hpp.sq"

    54

#include "ai_stationlist.hpp.sq"

    55

#include "ai_subsidy.hpp.sq"

    56

#include "ai_subsidylist.hpp.sq"

    57

#include "ai_testmode.hpp.sq"

    58

#include "ai_tile.hpp.sq"

    59

#include "ai_tilelist.hpp.sq"

    60

#include "ai_town.hpp.sq"

    61

#include "ai_townlist.hpp.sq"

    62

#include "ai_transactionmode.hpp.sq"

    63

#include "ai_tunnel.hpp.sq"

    64

#include "ai_vehicle.hpp.sq"

    65

#include "ai_vehiclelist.hpp.sq"

    66

    73

/* static */ void AIController::Sleep(int ticks)

    74

{

    75

	if (ticks <= 0) {

    76

		AILog::Warning("Sleep() value should be > 0. Assuming value 1.");

    77

		ticks = 1;

    78

	}

    79

	AI_SuspendPlayer(_current_player, ticks);

    80

}

    81

    82

/* static */ void AIController::Print(bool error_msg, const char *message)

    83

{

    84

	AILog::Log(error_msg ? AILog::LOG_SQ_ERROR : AILog::LOG_SQ_INFO, message);

    85

}

    86

    87

void AIController::RegisterClasses()

    88

{

    89

	this->engine->AddMethod("import", &AILibrary::Import, 4, "?ssi");

    90

    91

	/* Register all classes */

    92

	squirrel_register_std(this->engine);

    93

	SQAIAbstractList_Register(this->engine);

    94

	SQAIAccounting_Register(this->engine);

    95

	SQAIAirport_Register(this->engine);

    96

	SQAIBase_Register(this->engine);

    97

	SQAIBridge_Register(this->engine);

    98

	SQAIBridgeList_Register(this->engine);

    99

	SQAIBridgeList_Length_Register(this->engine);

   100

	SQAICargo_Register(this->engine);

   101

	SQAICargoList_Register(this->engine);

   102

	SQAICompany_Register(this->engine);

   103

	SQAIController_Register(this->engine);

   104

	SQAIDate_Register(this->engine);

   105

	SQAIDepotList_Register(this->engine);

   106

	SQAIEngine_Register(this->engine);

   107

	SQAIEngineList_Register(this->engine);

   108

	SQAIError_Register(this->engine);

   109

	SQAIEvent_Register(this->engine);

   110

	SQAIEventCompanyBankrupt_Register(this->engine);

   111

	SQAIEventCompanyInTrouble_Register(this->engine);

   112

	SQAIEventCompanyMerger_Register(this->engine);

   113

	SQAIEventCompanyNew_Register(this->engine);

   114

	SQAIEventController_Register(this->engine);

   115

	SQAIEventEngineAvailable_Register(this->engine);

   116

	SQAIEventEnginePreview_Register(this->engine);

   117

	SQAIEventIndustryClose_Register(this->engine);

   118

	SQAIEventIndustryOpen_Register(this->engine);

   119

	SQAIEventStationFirstVehicle_Register(this->engine);

   120

	SQAIEventSubsidyAwarded_Register(this->engine);

   121

	SQAIEventSubsidyExpired_Register(this->engine);

   122

	SQAIEventSubsidyOffer_Register(this->engine);

   123

	SQAIEventSubsidyOfferExpired_Register(this->engine);

   124

	SQAIEventTest_Register(this->engine);

   125

	SQAIEventVehicleCrashed_Register(this->engine);

   126

	SQAIEventVehicleLost_Register(this->engine);

   127

	SQAIEventVehicleUnprofitable_Register(this->engine);

   128

	SQAIEventVehicleWaitingInDepot_Register(this->engine);

   129

	SQAIExecMode_Register(this->engine);

   130

	SQAIGameSettings_Register(this->engine);

   131

	SQAIGroup_Register(this->engine);

   132

	SQAIGroupList_Register(this->engine);

   133

	SQAIIndustry_Register(this->engine);

   134

	SQAIIndustryList_Register(this->engine);

   135

	SQAIIndustryList_CargoAccepting_Register(this->engine);

   136

	SQAIIndustryList_CargoProducing_Register(this->engine);

   137

	SQAIList_Register(this->engine);

   138

	SQAILog_Register(this->engine);

   139

	SQAIMap_Register(this->engine);

   140

	SQAIMarine_Register(this->engine);

   141

	SQAIOrder_Register(this->engine);

   142

	SQAIRoad_Register(this->engine);

   143

	SQAISign_Register(this->engine);

   144

	SQAIStation_Register(this->engine);

   145

	SQAIStationList_Register(this->engine);

   146

	SQAIStationList_Vehicle_Register(this->engine);

   147

	SQAISubsidy_Register(this->engine);

   148

	SQAISubsidyList_Register(this->engine);

   149

	SQAITestMode_Register(this->engine);

   150

	SQAITile_Register(this->engine);

   151

	SQAITileList_Register(this->engine);

   152

	SQAITileList_IndustryAccepting_Register(this->engine);

   153

	SQAITileList_IndustryProducing_Register(this->engine);

   154

	SQAITileList_StationType_Register(this->engine);

   155

	SQAITown_Register(this->engine);

   156

	SQAITownList_Register(this->engine);

   157

	SQAITransactionMode_Register(this->engine);

   158

	SQAITunnel_Register(this->engine);

   159

	SQAIVehicle_Register(this->engine);

   160

	SQAIVehicleList_Register(this->engine);

   161

	SQAIVehicleList_Station_Register(this->engine);

   162

   163

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

   164

}

   165

   166

static void PrintFunc(bool error_msg, const SQChar *message)

   167

{

   168

	/* Convert to OpenTTD internal capable string */

   169

	AIController::Print(error_msg, FS2OTTD(message));

   170

}

   171

   172

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

   173

	tick(0),

   174

	engine(NULL),

   175

	SQ_instance(NULL),

   176

	loaded_library_count(0)

   177

{

   178

	this->script = strdup(script);

   179

	this->class_name = strdup(class_name);

   180

}

   181

   182

void AIController::Start()

   183

{

   184

	assert(this->engine == NULL);

   185

   186

	/* Create the Squirrel Engine and assign all required classes and settings */

   187

	this->engine = new Squirrel();

   188

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

   189

	this->RegisterClasses();

   190

	if (!this->engine->LoadScript(this->script)) {

   191

		delete this->engine;

   192

		this->engine = NULL;

   193

		return;

   194

	}

   195

	/* Create the main-class */

   196

	this->SQ_instance = MallocT<SQObject>(sizeof(SQObject));

   197

	if (!this->engine->CreateClassInstance(this->class_name, this, this->SQ_instance)) {

   198

		delete this->engine;

   199

		this->engine = NULL;

   200

		return;

   201

	}

   202

   203

	/* Run the constructor first */

   204

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

   205

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

   206

	}

   208

	/* When that is done, start the Start() function */

   209

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

   210

}

   211

   212

AIController::~AIController()

   213

{

   214

	if (this->engine != NULL) delete this->engine;

   215

	free(this->SQ_instance);

   216

	free((void *)this->script);

   217

	free((void *)this->class_name);

   218

   219

	for (LoadedLibraryList::iterator iter = this->loaded_library.begin(); iter != this->loaded_library.end(); iter++) {

   220

		free((void *)(*iter).second);

   221

		free((void *)(*iter).first);

   222

	}

   223

   224

	this->loaded_library.clear();

   225

}

   226

   227

void AIController::IncreaseTick()

   228

{

   229

	this->tick++;

   230

}

   231

   232

uint AIController::GetTick()

   233

{

   234

	return this->tick;

   235

}

   236

   237

bool AIController::LoadedLibrary(const char *library_name, int *next_number, char *fake_class_name, int fake_class_name_len)

   238

{

   239

	LoadedLibraryList::iterator iter = this->loaded_library.find(library_name);

   240

	if (iter == this->loaded_library.end()) {

   241

		*next_number = ++this->loaded_library_count;

   242

		return false;

   243

	}

   244

   245

	ttd_strlcpy(fake_class_name, (*iter).second, fake_class_name_len);

   246

	return true;

   247

}

   248

   249

void AIController::AddLoadedLibrary(const char *library_name, const char *fake_class_name)

   250

{

   251

	this->loaded_library[strdup(library_name)] = strdup(fake_class_name);

   252

}