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();

    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);

   111

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

   112

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

   113

	local engine = this.vehicle.FindBestAircraftVehicle(0, 0, (balance < 300000 ? 50000 : (balance < 1000000 ? 300000 : 1000000)));

   114

	if (!this.vehicle.IsValidEngine(engine)) {

   115

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

   116

		return -5;

   117

	}

   118

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

   119

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

   120

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

   121

		return -6;

   122

	}

   123

	/* Send him on his way */

   124

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

   125

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

   126

	this.vehicle.StartStopVehicle(vehicle);

   127

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

   128

	this.route_1.AddItem(vehicle, tile_1);

   129

	this.route_2.AddItem(vehicle, tile_2);

   130

   131

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

   132

   133

	return 0;

   134

}

   135

   136

/**

   137

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

   138

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

   139

 */

   140

function WrightAI::FindSuitableAirportSpot(airport_type, center_tile)

   141

{

   142

	local airport_x, airport_y, airport_rad;

   143

   144

	airport_x = AIAirport.GetAirportWidth(airport_type);

   145

	airport_y = AIAirport.GetAirportHeight(airport_type);

   146

	airport_rad = AIAirport.GetAirportCoverageRadius(airport_type);

   147

   148

	local town_list = AITownList();

   149

	/* Remove all the towns we already used */

   150

	town_list.RemoveList(this.towns_used);

   151

   152

	town_list.Valuate(AITownListPopulation());

   153

	town_list.KeepAboveValue(500);

   154

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

   155

	town_list.KeepTop(10);

   156

	town_list.Valuate(AIListRandomize());

   157

   158

	/* Now find 2 suitable towns */

   159

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

   160

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

   161

		Sleep(1);

   162

   163

		local tile = AITown.GetLocation(town);

   164

   165

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

   166

		local list = AITileList();

   167

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

   168

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

   169

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

   170

		list.KeepValue(1);

   171

		if (center_tile != 0) {

   172

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

   173

			list.Valuate(AITileListDistanceSquareToTile(center_tile));

   174

			list.KeepAboveValue(625);

   175

		}

   176

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

   177

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

   178

		list.RemoveBelowValue(10);

   179

   180

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

   181

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

   182

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

   183

		{

   184

			local test = AITestMode();

   185

			local good_tile = 0;

   186

   187

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

   188

				Sleep(1);

   189

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

   190

				good_tile = tile;

   191

				break;

   192

			}

   193

   194

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

   195

			if (good_tile == 0) continue;

   196

		}

   197

   198

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

   199

   200

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

   201

		this.towns_used.AddItem(town, tile);

   202

		return tile;

   203

	}

   204

   205

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

   206

	return -1;

   207

}

   208

   209

function WrightAI::ManageAirRoutes()

   210

{

   211

	local list = AIVehicleList();

   212

	list.Valuate(AIVehicleListAge());

   213

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

   214

	list.KeepAboveValue(365 * 2);

   215

	list.Valuate(AIVehicleListProfitLastYear());

   216

   217

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

   218

		local profit = list.GetValue(i);

   219

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

   220

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

   221

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

   222

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

   223

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

   224

				this.vehicle.SendVehicleToDepot(i);

   225

				this.vehicle_to_depot.rawset(i, true);

   226

			}

   227

		}

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

					/* Remove the airports */

   236

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

   237

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

   238

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

   241

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

   242

				}

   243

				this.vehicle_to_depot.rawdelete(i);

   244

			}

   245

		}

   246

	}

   247

   248

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

   249

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

   250

   251

	list = AIStationList(AIStation.STATION_AIRPORT);

   252

	list.Valuate(AIStationListCargoWaiting(0));

   253

	list.KeepAboveValue(250);

   254

   255

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

   256

		local list2 = AIStationVehicleList(i);

   257

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

   258

		/* TODO -- Sell station */

   259

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

   260

   261

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

   262

		local v = list2.Begin();

   263

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

   264

   265

		list2.Valuate(AIVehicleListAge());

   266

		list2.KeepBelowValue(dist);

   267

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

   268

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

   269

   270

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

   271

   272

		/* Make sure we have enough money */

   273

		this.GetMoney(50000);

   274

   275

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

   276

	}

   277

}

   278

   299

function WrightAI::Start()

   300

{

   301

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

   302

	Sleep(1);

   303

   304

	/* Give the boy a name */

   305

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

   306

		local i = 2;

   307

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

   308

			i++;

   309

		}

   310

	}

   311

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

   312

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

   313

   314

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

   315

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

   316

   317

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

   318

	local ticker = 0;

   319

	/* Let's go on for ever */

   320

	while (true) {

   321

		ticker++;

   322

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

   323

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

   324

			local ret = this.BuildAirportRoute();

   325

			if (ret == -1) {

   326

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

   327

				this.delay_build_airport_route = 10000;

   328

			}

   329

		}

   330

		/* Manage the routes once in a while */

   331

		if (ticker % 2000 == 0) {

   332

			this.ManageAirRoutes();

   333

		}

   334

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

   335

		if (ticker % 5000 == 0) {

   336

			this.company.SetLoanAmount(0);

   337

		}

   342

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

   343

		Sleep(1);

   344

	}

   345

}

   346

   347

function WrightAI::Stop()

   348

{

   349

}

   350

   351

class FWrightAI extends AIFactory {

   352

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

   353

	function GetName()        { return "WrightAI"; }

   354

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

   355

	function GetVersion()     { return 1; }

   356

	function GetDate()        { return "2007-07-15"; }

   357

	function CreateInstance() { return "WrightAI"; }

   358

}

   359

   360

/* Tell the core we are an AI */

   361

iFWrightAI <- FWrightAI();