1

     2

class WrightAI extends AIController {

     3

	airport = null;

     4

	company = null;

     5

	map = null;

     6

	order = null;

     7

	station = null;

     8

	vehicle = null;

     9

    10

	name = null;

    11

	towns_used = null;

    12

	route_1 = null;

    13

	route_2 = null;

    14

	distance_of_route = {};

    15

	vehicle_to_depot = {};

    16

	delay_build_airport_route = 1000;

    17

    18

	function Start();

    19

	function Stop();

    20

    21

	constructor() {

    22

		this.airport = AIAirport();

    23

		this.company = AICompany();

    24

		this.map = AIMap();

    25

		this.order = AIOrder();

    26

		this.station = AIStation();

    27

		this.vehicle = AIVehicle();

    28

    29

		this.towns_used = AIList();

    30

		this.route_1 = AIList();

    31

		this.route_2 = AIList();

    32

	}

    33

}

    34

    35

/**

    36

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

    37

 */

    38

function WrightAI::HasMoney(money)

    39

{

    40

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

    41

	return false;

    42

}

    43

    44

/**

    45

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

    46

 */

    47

function WrightAI::GetMoney(money)

    48

{

    49

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

    50

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

    51

    52

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

    53

	loan = loan - loan % this.company.GetLoanInterval();

    54

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

    55

	this.company.SetLoanAmount(loan);

    56

}

    57

    58

/**

    59

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

    60

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

    61

 */

    62

function WrightAI::BuildAirportRoute()

    63

{

    64

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

    65

    66

	/* Get enough money to work with */

    67

	this.GetMoney(150000);

    68

    69

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

    70

    71

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

    72

	if (tile_1 < 0) return -1;

    73

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

    74

	/* XXX -- If tile_2 isn't found, tile_1 town is added to used list, but never really used */

    75

	if (tile_2 < 0) return -2;

    76

    77

	/* Build the airports for real */

    78

	if (!this.airport.BuildAirport(tile_1, airport_type)) {

    79

		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 + ".");

    80

		/* XXX -- We should free the towns again for an other day */

    81

		return -3;

    82

	}

    83

	if (!this.airport.BuildAirport(tile_2, airport_type)) {

    84

		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 + ".");

    85

		this.airport.RemoveAirport(tile_1);

    86

		/* XXX -- We should free the towns again for an other day */

    87

		return -4;

    88

	}

    89

    90

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

    91

	if (ret < 0) {

    92

		this.airport.RemoveAirport(tile_1);

    93

		this.airport.RemoveAirport(tile_2);

    94

		/* XXX -- We should free the towns again for an other day */

    95

		return ret;

    96

	}

    97

    98

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

    99

	return ret;

   100

}

   101

   102

   103

/**

   104

 * Build an aircraft with orders from tile_1 to tile_2.

   105

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

   106

 */

   107

function WrightAI::BuildAircraft(tile_1, tile_2)

   108

{

   109

	/* Build an aircraft */

   110

	local hangar = this.airport.GetHangarOfAirport(tile_1);

   115

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

   116

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

   129

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

   130

		return -5;

   131

	}

   132

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

   133

	if (!this.vehicle.IsValidVehicle(vehicle)) {

   134

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

   135

		return -6;

   136

	}

   137

	/* Send him on his way */

   138

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

   139

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

   140

	this.vehicle.StartStopVehicle(vehicle);

   141

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

   142

	this.route_1.AddItem(vehicle, tile_1);

   143

	this.route_2.AddItem(vehicle, tile_2);

   144

   145

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

   146

   147

	return 0;

   148

}

   149

   150

/**

   151

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

   152

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

   153

 */

   154

function WrightAI::FindSuitableAirportSpot(airport_type, center_tile)

   155

{

   156

	local airport_x, airport_y, airport_rad;

   157

   158

	airport_x = AIAirport.GetAirportWidth(airport_type);

   159

	airport_y = AIAirport.GetAirportHeight(airport_type);

   160

	airport_rad = AIAirport.GetAirportCoverageRadius(airport_type);

   161

   162

	local town_list = AITownList();

   163

	/* Remove all the towns we already used */

   164

	town_list.RemoveList(this.towns_used);

   165

   166

	town_list.Valuate(AITownListPopulation());

   167

	town_list.KeepAboveValue(500);

   168

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

   169

	town_list.KeepTop(10);

   170

	town_list.Valuate(AIListRandomize());

   171

   172

	/* Now find 2 suitable towns */

   173

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

   174

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

   175

		Sleep(1);

   176

   177

		local tile = AITown.GetLocation(town);

   178

   179

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

   180

		local list = AITileList();

   181

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

   182

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

   183

		list.Valuate(AITileListBuildableRectangle(airport_x, airport_y));

   184

		list.KeepValue(1);

   185

		if (center_tile != 0) {

   186

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

   187

			list.Valuate(AITileListDistanceSquareToTile(center_tile));

   188

			list.KeepAboveValue(625);

   189

		}

   190

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

   191

		list.Valuate(AITileListCargoAcceptance(0, airport_x, airport_y, airport_rad));

   192

		list.RemoveBelowValue(10);

   193

   194

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

   195

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

   196

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

   197

		{

   198

			local test = AITestMode();

   199

			local good_tile = 0;

   200

   201

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

   202

				Sleep(1);

   203

				if (!this.airport.BuildAirport(tile, airport_type)) continue;

   204

				good_tile = tile;

   205

				break;

   206

			}

   207

   208

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

   209

			if (good_tile == 0) continue;

   210

		}

   211

   212

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

   213

   214

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

   215

		this.towns_used.AddItem(town, tile);

   216

		return tile;

   217

	}

   218

   219

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

   220

	return -1;

   221

}

   222

   223

function WrightAI::ManageAirRoutes()

   224

{

   225

	local list = AIVehicleList();

   226

	list.Valuate(AIVehicleListAge());

   227

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

   228

	list.KeepAboveValue(365 * 2);

   229

	list.Valuate(AIVehicleListProfitLastYear());

   230

   231

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

   232

		local profit = list.GetValue(i);

   233

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

   234

		if (profit < 10000 && this.vehicle.GetProfitThisYear(i) < 10000) {

   235

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

   236

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

   237

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

   238

				this.vehicle.SendVehicleToDepot(i);

   239

				this.vehicle_to_depot.rawset(i, true);

   240

			}

   241

		}

   242

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

   243

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

   244

			if (this.vehicle.SellVehicle(i)) {

   245

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

   246

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

   247

				local list2 = AIStationVehicleList(this.station.GetStationID(this.route_1.GetValue(i)));

   248

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

   249

					/* Remove the airports */

   250

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

   251

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

   252

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

   253

					this.route_1.RemoveItem(i);

   254

					this.route_2.RemoveItem(i);

   255

					/* XXX -- We should free the towns_used entries too */

   256

				}

   257

				this.vehicle_to_depot.rawdelete(i);

   258

			}

   259

		}

   260

	}

   261

   262

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

   263

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

   264

   265

	list = AIStationList(AIStation.STATION_AIRPORT);

   266

	list.Valuate(AIStationListCargoWaiting(0));

   267

	list.KeepAboveValue(250);

   268

   269

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

   270

		local list2 = AIStationVehicleList(i);

   271

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

   272

		/* TODO -- Sell station */

   273

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

   274

   275

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

   276

		local v = list2.Begin();

   277

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

   278

   279

		list2.Valuate(AIVehicleListAge());

   280

		list2.KeepBelowValue(dist);

   281

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

   282

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

   283

   284

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

   285

   286

		/* Make sure we have enough money */

   287

		this.GetMoney(50000);

   288

   289

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

   290

	}

   291

}

   292

   293

function WrightAI::HandleEvents()

   294

{

   295

	while (AIEventController.IsEventWaiting()) {

   296

		local e = AIEventController.GetNextEvent();

   297

		switch (e.GetEventType()) {

   298

			case AIEvent.AI_ET_CRASHED_VEHICLE:

   299

				local ec = AIEventVehicleCrash.Convert(e);

   300

				local v = ec.GetVehicleID();

   301

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

   302

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

   303

				this.route_1.RemoveItem(v);

   304

				this.route_2.RemoveItem(v);

   305

				break;

   306

   307

			default:

   308

				break;

   309

		}

   310

	}

   311

}

   312

   313

function WrightAI::Start()

   314

{

   315

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

   316

	Sleep(1);

   317

   318

	/* Give the boy a name */

   319

	if (!this.company.SetCompanyName("WrightAI")) {

   320

		local i = 2;

   321

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

   322

			i++;

   323

		}

   324

	}

   325

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

   326

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

   327

   328

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

   329

	this.company.SetLoanAmount(this.company.GetLoanInterval());

   330

   331

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

   332

	local ticker = 0;

   333

	/* Let's go on for ever */

   334

	while (true) {

   335

		ticker++;

   336

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

   337

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

   338

			local ret = this.BuildAirportRoute();

   339

			if (ret == -1) {

   340

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

   341

				this.delay_build_airport_route = 10000;

   342

			}

   343

		}

   344

		/* Manage the routes once in a while */

   345

		if (ticker % 2000 == 0) {

   346

			this.ManageAirRoutes();

   347

		}

   348

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

   349

		if (ticker % 5000 == 0) {

   350

			this.company.SetLoanAmount(0);

   351

		}

   352

		/* Check for events once in a while */

   353

		if (ticker % 100 == 0) {

   354

			this.HandleEvents();

   355

		}

   356

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

   357

		Sleep(1);

   358

	}

   359

}

   360

   361

function WrightAI::Stop()

   362

{

   363

}

   364

   365

class FWrightAI extends AIFactory {

   366

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

   367

	function GetName()        { return "WrightAI"; }

   368

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

   369

	function GetVersion()     { return 1; }

   371

	function CreateInstance() { return "WrightAI"; }

   372

}

   373

   374

/* Tell the core we are an AI */

   375

iFWrightAI <- FWrightAI();