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_engine.hpp.sq"

    35

#include "ai_enginelist.hpp.sq"

    36

#include "ai_error.hpp.sq"

    37

#include "ai_event.hpp.sq"

    38

#include "ai_event_types.hpp.sq"

    39

#include "ai_execmode.hpp.sq"

    40

#include "ai_gamesettings.hpp.sq"

    41

#include "ai_industry.hpp.sq"

    42

#include "ai_industrylist.hpp.sq"

    43

#include "ai_list.hpp.sq"

    44

#include "ai_log.hpp.sq"

    45

#include "ai_map.hpp.sq"

    46

#include "ai_marine.hpp.sq"

    47

#include "ai_order.hpp.sq"

    48

#include "ai_road.hpp.sq"

    49

#include "ai_settings.hpp.sq"

    50

#include "ai_sign.hpp.sq"

    51

#include "ai_station.hpp.sq"

    52

#include "ai_stationlist.hpp.sq"

    53

#include "ai_subsidy.hpp.sq"

    54

#include "ai_subsidylist.hpp.sq"

    55

#include "ai_testmode.hpp.sq"

    56

#include "ai_tile.hpp.sq"

    57

#include "ai_tilelist.hpp.sq"

    58

#include "ai_town.hpp.sq"

    59

#include "ai_townlist.hpp.sq"

    60

#include "ai_transactionmode.hpp.sq"

    61

#include "ai_tunnel.hpp.sq"

    62

#include "ai_vehicle.hpp.sq"

    63

#include "ai_vehiclelist.hpp.sq"

    64

    65

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

    66

{

    67

	AI_SuspendPlayer(_current_player, ticks);

    68

}

    69

    70

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

    71

{

    72

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

    73

}

    74

    75

void AIController::RegisterClasses()

    76

{

    77

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

    78

    79

	/* Register all classes */

    80

	squirrel_register_std(this->engine);

    81

	SQAIAbstractList_Register(this->engine);

    82

	SQAIAccounting_Register(this->engine);

    83

	SQAIAirport_Register(this->engine);

    84

	SQAIBase_Register(this->engine);

    85

	SQAIBridge_Register(this->engine);

    86

	SQAIBridgeList_Register(this->engine);

    87

	SQAIBridgeList_Length_Register(this->engine);

    88

	SQAICargo_Register(this->engine);

    89

	SQAICargoList_Register(this->engine);

    90

	SQAICompany_Register(this->engine);

    91

	SQAIController_Register(this->engine);

    92

	SQAIDate_Register(this->engine);

    93

	SQAIEngine_Register(this->engine);

    94

	SQAIEngineList_Register(this->engine);

    95

	SQAIError_Register(this->engine);

    96

	SQAIEvent_Register(this->engine);

    97

	SQAIEventCompanyBankrupt_Register(this->engine);

    98

	SQAIEventCompanyInTrouble_Register(this->engine);

    99

	SQAIEventCompanyMerger_Register(this->engine);

   100

	SQAIEventCompanyNew_Register(this->engine);

   101

	SQAIEventController_Register(this->engine);

   103

	SQAIEventEnginePreview_Register(this->engine);

   104

	SQAIEventIndustryClose_Register(this->engine);

   105

	SQAIEventIndustryOpen_Register(this->engine);

   106

	SQAIEventSubsidyAwarded_Register(this->engine);

   107

	SQAIEventSubsidyExpired_Register(this->engine);

   108

	SQAIEventSubsidyOffer_Register(this->engine);

   109

	SQAIEventSubsidyOfferExpired_Register(this->engine);

   110

	SQAIEventTest_Register(this->engine);

   111

	SQAIEventVehicleCrash_Register(this->engine);

   112

	SQAIEventVehicleLost_Register(this->engine);

   113

	SQAIEventVehicleUnprofitable_Register(this->engine);

   114

	SQAIEventVehicleWaitingInDepot_Register(this->engine);

   115

	SQAIExecMode_Register(this->engine);

   116

	SQAIGameSettings_Register(this->engine);

   117

	SQAIIndustry_Register(this->engine);

   118

	SQAIIndustryList_Register(this->engine);

   119

	SQAIIndustryList_CargoAccepting_Register(this->engine);

   120

	SQAIIndustryList_CargoProducing_Register(this->engine);

   121

	SQAIList_Register(this->engine);

   122

	SQAILog_Register(this->engine);

   123

	SQAIMap_Register(this->engine);

   124

	SQAIMarine_Register(this->engine);

   125

	SQAIOrder_Register(this->engine);

   126

	SQAIRoad_Register(this->engine);

   127

	SQAISettings_Register(this->engine);

   128

	SQAISign_Register(this->engine);

   129

	SQAIStation_Register(this->engine);

   130

	SQAIStationList_Register(this->engine);

   131

	SQAIStationList_Vehicle_Register(this->engine);

   132

	SQAISubsidy_Register(this->engine);

   133

	SQAISubsidyList_Register(this->engine);

   134

	SQAITestMode_Register(this->engine);

   135

	SQAITile_Register(this->engine);

   136

	SQAITileList_Register(this->engine);

   137

	SQAITileList_IndustryAccepting_Register(this->engine);

   138

	SQAITileList_IndustryProducing_Register(this->engine);

   139

	SQAITileList_StationType_Register(this->engine);

   140

	SQAITown_Register(this->engine);

   141

	SQAITownList_Register(this->engine);

   142

	SQAITransactionMode_Register(this->engine);

   143

	SQAITunnel_Register(this->engine);

   144

	SQAIVehicle_Register(this->engine);

   145

	SQAIVehicleList_Register(this->engine);

   146

	SQAIVehicleList_Station_Register(this->engine);

   147

   148

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

   149

}

   150

   151

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

   152

{

   153

	/* Convert to OpenTTD internal capable string */

   154

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

   155

}

   156

   157

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

   158

	tick(0),

   159

	engine(NULL),

   160

	SQ_instance(NULL),

   161

	loaded_library_count(0)

   162

{

   163

	this->script = strdup(script);

   164

	this->class_name = strdup(class_name);

   165

}

   166

   167

void AIController::Start()

   168

{

   169

	assert(this->engine == NULL);

   170

   171

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

   172

	this->engine = new Squirrel();

   173

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

   174

	this->RegisterClasses();

   175

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

   176

		delete this->engine;

   177

		this->engine = NULL;

   178

		return;

   179

	}

   180

	/* Create the main-class */

   181

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

   182

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

   183

		delete this->engine;

   184

		this->engine = NULL;

   185

		return;

   186

	}

   187

   188

	/* Run the constructor first */

   189

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

   190

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

   191

	}

   192

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

   193

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

   194

}

   195

   196

AIController::~AIController()

   197

{

   198

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

   199

	free(this->SQ_instance);

   200

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

   201

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

   202

   203

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

   204

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

   205

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

   206

	}

   207

   208

	this->loaded_library.clear();

   209

}

   210

   211

void AIController::IncreaseTick()

   212

{

   213

	this->tick++;

   214

}

   215

   216

uint AIController::GetTick()

   217

{

   218

	return this->tick;

   219

}

   220

   221

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

   222

{

   223

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

   224

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

   225

		*next_number = ++this->loaded_library_count;

   226

		return false;

   227

	}

   228

   229

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

   230

	return true;

   231

}

   232

   233

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

   234

{

   235

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

   236

}