1

     2

class WrightAI extends AIController {

     3

	name = null;

     4

	towns_used = null;

     5

	route_1 = null;

     6

	route_2 = null;

     7

	distance_of_route = {};

     8

	vehicle_to_depot = {};

     9

	delay_build_airport_route = 1000;

    10

    11

	function Start();

    12

	function Stop();

    13

    14

	constructor() {

    15

		this.towns_used = AIList();

    16

		this.route_1 = AIList();

    17

		this.route_2 = AIList();

    18

	}

    19

}

    20

    21

/**

    22

 * Check if we have enough money (via loan and on bank).

    23

 */

    24

function WrightAI::HasMoney(money)

    25

{

    26

	if (AICompany.GetBankBalance(AICompany.MY_COMPANY) + (AICompany.GetMaxLoanAmount() - AICompany.GetLoanAmount()) > money) return true;

    27

	return false;

    28

}

    29

    30

/**

    31

 * Get the amount of money requested, loan if needed.

    32

 */

    33

function WrightAI::GetMoney(money)

    34

{

    35

	if (!this.HasMoney(money)) return;

    36

	if (AICompany.GetBankBalance(AICompany.MY_COMPANY) > money) return;

    37

    38

	local loan = money - AICompany.GetBankBalance(AICompany.MY_COMPANY) + AICompany.GetLoanInterval() + AICompany.GetLoanAmount();

    39

	loan = loan - loan % AICompany.GetLoanInterval();

    40

	print(this.name + ": [INFO] Need a loan to get " + money + ": " + loan);

    41

	AICompany.SetLoanAmount(loan);

    42

}

    43

    44

/**

    45

 * Build an airport route. Find 2 cities that are big enough and try to build airport in both cities.

    46

 *  Then we can build an aircraft and make some money.

    47

 */

    48

function WrightAI::BuildAirportRoute()

    49

{

    50

	local airport_type = (AIAirport.AiportAvailable(AIAirport.AT_SMALL) ? AIAirport.AT_SMALL : AIAirport.AT_LARGE);

    51

    52

	/* Get enough money to work with */

    53

	this.GetMoney(150000);

    54

    55

	print(this.name + ": [INFO] Trying to build an airport route");

    56

    57

	local tile_1 = this.FindSuitableAirportSpot(airport_type, 0);

    58

	if (tile_1 < 0) return -1;

    59

	local tile_2 = this.FindSuitableAirportSpot(airport_type, tile_1);

    60

	if (tile_2 < 0) {

    61

		this.towns_used.RemoveValue(tile_1);

    62

		return -2;

    63

	}

    64

    65

	/* Build the airports for real */

    66

	if (!AIAirport.BuildAirport(tile_1, airport_type)) {

    67

		print(this.name + ": [ERROR] Although the testing told us we could build 2 airports, it still failed on the first airport at tile " + tile_1 + ".");

    68

		this.towns_used.RemoveValue(tile_1);

    69

		this.towns_used.RemoveValue(tile_2);

    70

		return -3;

    71

	}

    72

	if (!AIAirport.BuildAirport(tile_2, airport_type)) {

    73

		print(this.name + ": [ERROR] Although the testing told us we could build 2 airports, it still failed on the second airport at tile " + tile_2 + ".");

    74

		AIAirport.RemoveAirport(tile_1);

    75

		this.towns_used.RemoveValue(tile_1);

    76

		this.towns_used.RemoveValue(tile_2);

    77

		return -4;

    78

	}

    79

    80

	local ret = this.BuildAircraft(tile_1, tile_2);

    81

	if (ret < 0) {

    82

		AIAirport.RemoveAirport(tile_1);

    83

		AIAirport.RemoveAirport(tile_2);

    84

		this.towns_used.RemoveValue(tile_1);

    85

		this.towns_used.RemoveValue(tile_2);

    86

		return ret;

    87

	}

    88

    89

	print(this.name + ": [INFO] Done building a route");

    90

	return ret;

    91

}

    92

    93

/**

    94

 * Build an aircraft with orders from tile_1 to tile_2.

    95

 *  The best available aircraft of that time will be bought.

    96

 */

    97

function WrightAI::BuildAircraft(tile_1, tile_2)

    98

{

    99

	/* Build an aircraft */

   100

	local hangar = AIAirport.GetHangarOfAirport(tile_1);

   101

	local engine = null;

   102

   103

	local engine_list = AIEngineList(AIVehicle.VEHICLE_AIR);

   104

   105

	/* When bank balance < 300000, buy cheaper planes */

   106

	local balance = AICompany.GetBankBalance(AICompany.MY_COMPANY);

   108

	engine_list.KeepBelowValue(balance < 300000 ? 50000 : (balance < 1000000 ? 300000 : 1000000));

   109

   111

	engine_list.KeepValue(0); // passengers

   112

   114

	engine_list.KeepTop(1);

   115

   116

	engine = engine_list.Begin();

   117

   118

	if (!AIEngine.IsValidEngine(engine)) {

   119

		print(this.name + ": [ERROR] Couldn't find a suitable engine");

   120

		return -5;

   121

	}

   122

	local vehicle = AIVehicle.BuildVehicle(hangar, engine);

   123

	if (!AIVehicle.IsValidVehicle(vehicle)) {

   124

		print(this.name + ": [ERROR] Couldn't build the aircraft");

   125

		return -6;

   126

	}

   127

	/* Send him on his way */

   128

	AIOrder.AppendOrder(vehicle, tile_1, AIOrder.AIOF_NONE);

   129

	AIOrder.AppendOrder(vehicle, tile_2, AIOrder.AIOF_NONE);

   130

	AIVehicle.StartStopVehicle(vehicle);

   131

	this.distance_of_route.rawset(vehicle, AIMap.DistanceManhattan(tile_1, tile_2));

   132

	this.route_1.AddItem(vehicle, tile_1);

   133

	this.route_2.AddItem(vehicle, tile_2);

   134

   135

	print(this.name + ": [INFO] Done building an aircraft");

   136

   137

	return 0;

   138

}

   139

   140

/**

   141

 * Find a suitable spot for an airport, walking all towns hoping to find one.

   142

 *  When a town is used, it is marked as such and not re-used.

   143

 */

   144

function WrightAI::FindSuitableAirportSpot(airport_type, center_tile)

   145

{

   146

	local airport_x, airport_y, airport_rad;

   147

   148

	airport_x = AIAirport.GetAirportWidth(airport_type);

   149

	airport_y = AIAirport.GetAirportHeight(airport_type);

   150

	airport_rad = AIAirport.GetAirportCoverageRadius(airport_type);

   151

   152

	local town_list = AITownList();

   153

	/* Remove all the towns we already used */

   154

	town_list.RemoveList(this.towns_used);

   155

   157

	town_list.KeepAboveValue(500);

   158

	/* Keep the best 10, if we can't find 2 stations in there, just leave it anyway */

   159

	town_list.KeepTop(10);

   161

   162

	/* Now find 2 suitable towns */

   163

	for (local town = town_list.Begin(); town_list.HasNext(); town = town_list.Next()) {

   164

		/* Don't make this a CPU hog */

   165

		Sleep(1);

   166

   167

		local tile = AITown.GetLocation(town);

   168

   169

		/* Create a 30x30 grid around the core of the town and see if we can find a spot for a small airport */

   170

		local list = AITileList();

   171

		/* XXX -- We assume we are more than 15 tiles away from the border! */

   172

		list.AddRectangle(tile - AIMap.GetTileIndex(15, 15), tile + AIMap.GetTileIndex(15, 15));

   174

		list.KeepValue(1);

   175

		if (center_tile != 0) {

   176

			/* If we have a tile defined, we don't want to be within 25 tiles of this tile */

   178

			list.KeepAboveValue(625);

   179

		}

   180

		/* Sort on acceptance, remove places that don't have acceptance */

   182

		list.RemoveBelowValue(10);

   183

   184

		/* Couldn't find a suitable place for this town, skip to the next */

   185

		if (list.Count() == 0) continue;

   186

		/* Walk all the tiles and see if we can build the airport at all */

   187

		{

   188

			local test = AITestMode();

   189

			local good_tile = 0;

   190

   191

			for (tile = list.Begin(); list.HasNext(); tile = list.Next()) {

   192

				Sleep(1);

   193

				if (!AIAirport.BuildAirport(tile, airport_type)) continue;

   194

				good_tile = tile;

   195

				break;

   196

			}

   197

   198

			/* Did we found a place to build the airport on? */

   199

			if (good_tile == 0) continue;

   200

		}

   201

   202

		print(this.name + ": [INFO] Found a good spot for an airport in town " + town + " at tile " + tile);

   203

   204

		/* Make the town as used, so we don't use it again */

   205

		this.towns_used.AddItem(town, tile);

   206

   207

		return tile;

   208

	}

   209

   210

	print(this.name + ": [INFO] Couldn't find a suitable town to build an airport in");

   211

	return -1;

   212

}

   213

   214

function WrightAI::ManageAirRoutes()

   215

{

   216

	local list = AIVehicleList();

   218

	/* Give the plane at least 2 years to make a difference */

   219

	list.KeepAboveValue(365 * 2);

   221

   222

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

   223

		local profit = list.GetValue(i);

   224

		/* Profit last year and this year bad? Let's sell the vehicle */

   225

		if (profit < 10000 && AIVehicle.GetProfitThisYear(i) < 10000) {

   226

			/* Send the vehicle to depot if we didn't do so yet */

   227

			if (!vehicle_to_depot.rawin(i) || vehicle_to_depot.rawget(i) != true) {

   228

				print(this.name + ": [INFO] Sending " + i + " to depot as profit is: " + profit + " / " + AIVehicle.GetProfitThisYear(i));

   229

				AIVehicle.SendVehicleToDepot(i);

   230

				vehicle_to_depot.rawset(i, true);

   231

			}

   232

		}

   233

		/* Try to sell it over and over till it really is in the depot */

   234

		if (vehicle_to_depot.rawin(i) && vehicle_to_depot.rawget(i) == true) {

   235

			if (AIVehicle.SellVehicle(i)) {

   236

				print(this.name + ": [INFO] Selling " + i + " as it finally is in a depot.");

   237

				/* Check if we are the last one serving those airports; else sell the airports */

   238

				local list2 = AIVehicleList_Station(AIStation.GetStationID(this.route_1.GetValue(i)));

   239

				if (list2.Count() == 0) this.SellAirports(i);

   240

				vehicle_to_depot.rawdelete(i);

   241

			}

   242

		}

   243

	}

   244

   245

	/* Don't try to add planes when we are short on cash */

   246

	if (!this.HasMoney(50000)) return;

   247

   248

	list = AIStationList(AIStation.STATION_AIRPORT);

   250

	list.KeepAboveValue(250);

   251

   252

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

   253

		local list2 = AIVehicleList_Station(i);

   254

		/* No vehicles going to this station, abort and sell */

   255

		if (list2.Count() == 0) {

   256

			this.SellAirports(i);

   257

			continue;

   258

		};

   259

   260

		/* Find the first vehicle that is going to this station */

   261

		local v = list2.Begin();

   262

		local dist = this.distance_of_route.rawget(v);

   263

   265

		list2.KeepBelowValue(dist);

   266

		/* Do not build a new vehicle if we bought a new one in the last DISTANCE days */

   267

		if (list2.Count() != 0) continue;

   268

   269

		print(this.name + ": [INFO] Station " + i + " (" + AIStation.GetLocation(i) + ") has too many cargo, adding a new vehicle for the route.");

   270

   271

		/* Make sure we have enough money */

   272

		this.GetMoney(50000);

   273

   274

		return this.BuildAircraft(this.route_1.GetValue(v), this.route_2.GetValue(v));

   275

	}

   276

}

   277

   278

/**

   279

  * Sells the airports from route index i

   280

  * Removes towns from towns_used list too

   281

  */

   282

function WrightAI::SellAirports(i) {

   283

	/* Remove the airports */

   284

	print(this.name + ": [INFO] Removing airports as nobody serves them anymore.");

   285

	AIAirport.RemoveAirport(this.route_1.GetValue(i));

   286

	AIAirport.RemoveAirport(this.route_2.GetValue(i));

   287

	/* Free the towns_used entries */

   288

	this.towns_used.RemoveValue(this.route_1.GetValue(i));

   289

	this.towns_used.RemoveValue(this.route_2.GetValue(i));

   290

	/* Remove the route */

   291

	this.route_1.RemoveItem(i);

   292

	this.route_2.RemoveItem(i);

   293

}

   294

   295

function WrightAI::HandleEvents()

   296

{

   297

	while (AIEventController.IsEventWaiting()) {

   298

		local e = AIEventController.GetNextEvent();

   299

		switch (e.GetEventType()) {

   300

			case AIEvent.AI_ET_CRASHED_VEHICLE:

   301

				local ec = AIEventVehicleCrash.Convert(e);

   302

				local v = ec.GetVehicleID();

   303

				print(this.name + ": [INFO] We have a crashed vehicle (" + v + "), buying a new one as replacement");

   304

				this.BuildAircraft(this.route_1.GetValue(v), this.route_2.GetValue(v));

   305

				this.route_1.RemoveItem(v);

   306

				this.route_2.RemoveItem(v);

   307

				break;

   308

   309

			default:

   310

				break;

   311

		}

   312

	}

   313

}

   314

   315

function WrightAI::Start()

   316

{

   317

	/* Sleep 1 tick, as we can't execute anything in tick 0 */

   318

	Sleep(1);

   319

   320

	/* Give the boy a name */

   321

	if (!AICompany.SetCompanyName("WrightAI")) {

   322

		local i = 2;

   323

		while (!AICompany.SetCompanyName("WrightAI #" + i)) {

   324

			i++;

   325

		}

   326

	}

   327

	this.name = AICompany.GetCompanyName(AICompany.MY_COMPANY);

   328

	/* Say hello to the user */

   329

	print(this.name + ": Welcome to WrightAI. I will be building airports all day long.");

   330

   331

	/* We start with almost no loan, and we take a loan when we want to build something */

   332

	AICompany.SetLoanAmount(AICompany.GetLoanInterval());

   333

   334

	/* We need our local ticker, as GetTick() will skip ticks */

   335

	local ticker = 0;

   336

	/* Determine time we may sleep */

   337

	local sleepingtime = 100;

   338

	if (this.delay_build_airport_route < sleepingtime)

   339

		sleepingtime = this.delay_build_airport_route;

   340

   341

	/* Let's go on for ever */

   342

	while (true) {

   343

		/* Once in a while, with enough money, try to build something */

   344

		if ((ticker % this.delay_build_airport_route == 0 || ticker == 0) && this.HasMoney(100000)) {

   345

			local ret = this.BuildAirportRoute();

   346

			if (ret == -1 && ticker != 0) {

   347

				/* No more route found, delay even more before trying to find an other */

   348

				this.delay_build_airport_route = 10000;

   349

			}

   350

			else if (ret < 0 && ticker == 0) {

   351

				/* The AI failed to build a first airport and is deemed */

   352

				this.ChangeName("FailedWrightAI");

   353

				print(this.name + ": Failed to build first airport route, now giving up building. Repaying loan. Have a nice day!");

   354

				AICompany.SetLoanAmount(0);

   355

				return;

   356

			}

   357

		}

   358

		/* Manage the routes once in a while */

   359

		if (ticker % 2000 == 0) {

   360

			this.ManageAirRoutes();

   361

		}

   362

		/* Try to get ride of our loan once in a while */

   363

		if (ticker % 5000 == 0) {

   364

			AICompany.SetLoanAmount(0);

   365

		}

   366

		/* Check for events once in a while */

   367

		if (ticker % 100 == 0) {

   368

			this.HandleEvents();

   369

		}

   370

		/* Make sure we do not create infinite loops */

   371

		Sleep(sleepingtime);

   372

		ticker += sleepingtime;

   373

	}

   374

}

   375

   376

function WrightAI::Stop()

   377

{

   378

}

   379

   380

class FWrightAI extends AIFactory {

   381

	function GetAuthor()      { return "OpenTTD Dev Team"; }

   382

	function GetName()        { return "WrightAI"; }

   383

	function GetDescription() { return "A simple AI that tries to beat you with only aircrafts"; }

   384

	function GetVersion()     { return 1.1; }

   385

	function GetDate()        { return "2008-02-24"; }

   386

	function CreateInstance() { return "WrightAI"; }

   387

}

   388

   389

/* Tell the core we are an AI */

   390

iFWrightAI <- FWrightAI();