1

/* $Id$ */

     2

     3

/*

     4

 * This AI was created as a direct reaction to the big demand for some good AIs

     5

 * in OTTD. Too bad it never left alpha-stage, and it is considered dead in its

     6

 * current form.

     7

 * By the time of writing this, we, the creator of this AI and a good friend of

     8

 * mine, are designing a whole new AI-system that allows us to create AIs

     9

 * easier and without all the fuzz we encountered while I was working on this

    10

 * AI. By the time that system is finished, you can expect that this AI will

    11

 * dissapear, because it is pretty obselete and bad programmed.

    12

 *

    13

 * Meanwhile I wish you all much fun with this AI; if you are interested as

    14

 * AI-developer in this AI, I advise you not stare too long to some code, some

    15

 * things in here really are... strange ;) But in either way: enjoy :)

    16

 *

    17

 *  -- TrueLight :: 2005-09-01

    18

 */

    19

    20

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

    21

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

    22

#include "../../debug.h"

    23

#include "../../road_map.h"

    24

#include "../../station_map.h"

    25

#include "../../command_func.h"

    26

#include "trolly.h"

    27

#include "../../town.h"

    28

#include "../../industry.h"

    29

#include "../../station_base.h"

    31

#include "../../gui.h"

    32

#include "../../depot.h"

    33

#include "../../vehicle_base.h"

    34

#include "../../vehicle_func.h"

    35

#include "../../date_func.h"

    36

#include "../ai.h"

    37

#include "../../player_base.h"

    38

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

    39

    40

#include "table/strings.h"

    41

    42

PlayerAiNew _players_ainew[MAX_PLAYERS];

    43

    44

// This function is called after StartUp. It is the init of an AI

    45

static void AiNew_State_FirstTime(Player *p)

    46

{

    47

	// This assert is used to protect those function from misuse

    48

	//   You have quickly a small mistake in the state-array

    49

	//   With that, everything would go wrong. Finding that, is almost impossible

    50

	//   With this assert, that problem can never happen.

    51

	assert(_players_ainew[p->index].state == AI_STATE_FIRST_TIME);

    52

	// We first have to init some things

    53

    54

	if (_current_player == 1) ShowErrorMessage(INVALID_STRING_ID, TEMP_AI_IN_PROGRESS, 0, 0);

    55

    56

	// The PathFinder (AyStar)

    57

	// TODO: Maybe when an AI goes bankrupt, this is de-init

    58

	//  or when coming from a savegame.. should be checked out!

    59

	_players_ainew[p->index].path_info.start_tile_tl = 0;

    60

	_players_ainew[p->index].path_info.start_tile_br = 0;

    61

	_players_ainew[p->index].path_info.end_tile_tl = 0;

    62

	_players_ainew[p->index].path_info.end_tile_br = 0;

    63

	_players_ainew[p->index].pathfinder = new_AyStar_AiPathFinder(12, &_players_ainew[p->index].path_info);

    64

    65

	_players_ainew[p->index].idle = 0;

    66

	_players_ainew[p->index].last_vehiclecheck_date = _date;

    67

    68

	// We ALWAYS start with a bus route.. just some basic money ;)

    69

	_players_ainew[p->index].action = AI_ACTION_BUS_ROUTE;

    70

    71

	// Let's popup the news, and after that, start building..

    72

	_players_ainew[p->index].state = AI_STATE_WAKE_UP;

    73

}

    74

    75

    76

// This function just waste some time

    77

//  It keeps it more real. The AI can build on such tempo no normal user

    78

//  can ever keep up with that. The competitor_speed already delays a bit

    79

//  but after the AI finished a track it really needs to go to sleep.

    80

//

    81

// Let's say, we sleep between one and three days if the AI is put on Very Fast.

    82

//  This means that on Very Slow it will be between 16 and 48 days.. slow enough?

    83

static void AiNew_State_Nothing(Player *p)

    84

{

    85

	assert(_players_ainew[p->index].state == AI_STATE_NOTHING);

    86

	// If we are done idling, start over again

    87

	if (_players_ainew[p->index].idle == 0) _players_ainew[p->index].idle = AI_RandomRange(DAY_TICKS * 2) + DAY_TICKS;

    88

	if (--_players_ainew[p->index].idle == 0) {

    89

		// We are done idling.. what you say? Let's do something!

    90

		// I mean.. the next tick ;)

    91

		_players_ainew[p->index].state = AI_STATE_WAKE_UP;

    92

	}

    93

}

    94

    95

    96

// This function picks out a task we are going to do.

    97

//  Currently supported:

    98

//    - Make new route

    99

//    - Check route

   100

//    - Build HQ

   101

static void AiNew_State_WakeUp(Player *p)

   102

{

   103

	int c;

   104

	assert(_players_ainew[p->index].state == AI_STATE_WAKE_UP);

   105

	// First, check if we have a HQ

   106

	if (p->location_of_house == 0) {

   107

		// We have no HQ yet, build one on a random place

   108

		// Random till we found a place for it!

   109

		// TODO: this should not be on a random place..

   110

		AiNew_Build_CompanyHQ(p, AI_Random() % MapSize());

   111

		// Enough for now, but we want to come back here the next time

   112

		//  so we do not change any status

   113

		return;

   114

	}

   115

   116

	Money money = p->player_money - AI_MINIMUM_MONEY;

   117

   118

	// Let's pick an action!

   119

	if (_players_ainew[p->index].action == AI_ACTION_NONE) {

   120

		c = AI_Random() & 0xFF;

   121

		if (p->current_loan > 0 &&

   122

				p->old_economy[1].income > AI_MINIMUM_INCOME_FOR_LOAN &&

   123

				c < 10) {

   124

			_players_ainew[p->index].action = AI_ACTION_REPAY_LOAN;

   125

		} else if (_players_ainew[p->index].last_vehiclecheck_date + AI_DAYS_BETWEEN_VEHICLE_CHECKS < _date) {

   126

			// Check all vehicles once in a while

   127

			_players_ainew[p->index].action = AI_ACTION_CHECK_ALL_VEHICLES;

   128

			_players_ainew[p->index].last_vehiclecheck_date = _date;

   129

		} else if (c < 100 && !_patches.ai_disable_veh_roadveh) {

   130

			// Do we have any spots for road-vehicles left open?

   131

			if (GetFreeUnitNumber(VEH_ROAD) <= _patches.max_roadveh) {

   132

				if (c < 85) {

   133

					_players_ainew[p->index].action = AI_ACTION_TRUCK_ROUTE;

   134

				} else {

   135

					_players_ainew[p->index].action = AI_ACTION_BUS_ROUTE;

   136

				}

   137

			}

   138

#if 0

   139

		} else if (c < 200 && !_patches.ai_disable_veh_train) {

   140

			if (GetFreeUnitNumber(VEH_TRAIN) <= _patches.max_trains) {

   141

				_players_ainew[p->index].action = AI_ACTION_TRAIN_ROUTE;

   142

			}

   143

#endif

   144

		}

   145

   146

		_players_ainew[p->index].counter = 0;

   147

	}

   148

   149

	if (_players_ainew[p->index].counter++ > AI_MAX_TRIES_FOR_SAME_ROUTE) {

   150

		_players_ainew[p->index].action = AI_ACTION_NONE;

   151

		return;

   152

	}

   153

   154

	if (_patches.ai_disable_veh_roadveh && (

   155

				_players_ainew[p->index].action == AI_ACTION_BUS_ROUTE ||

   156

				_players_ainew[p->index].action == AI_ACTION_TRUCK_ROUTE

   157

			)) {

   158

		_players_ainew[p->index].action = AI_ACTION_NONE;

   159

		return;

   160

	}

   161

   162

	if (_players_ainew[p->index].action == AI_ACTION_REPAY_LOAN &&

   163

			money > AI_MINIMUM_LOAN_REPAY_MONEY) {

   164

		// We start repaying some money..

   165

		_players_ainew[p->index].state = AI_STATE_REPAY_MONEY;

   166

		return;

   167

	}

   168

   169

	if (_players_ainew[p->index].action == AI_ACTION_CHECK_ALL_VEHICLES) {

   170

		_players_ainew[p->index].state = AI_STATE_CHECK_ALL_VEHICLES;

   171

		return;

   172

	}

   173

   174

	// It is useless to start finding a route if we don't have enough money

   175

	//  to build the route anyway..

   176

	if (_players_ainew[p->index].action == AI_ACTION_BUS_ROUTE &&

   177

			money > AI_MINIMUM_BUS_ROUTE_MONEY) {

   178

		if (GetFreeUnitNumber(VEH_ROAD) > _patches.max_roadveh) {

   179

			_players_ainew[p->index].action = AI_ACTION_NONE;

   180

			return;

   181

		}

   182

		_players_ainew[p->index].cargo = AI_NEED_CARGO;

   183

		_players_ainew[p->index].state = AI_STATE_LOCATE_ROUTE;

   184

		_players_ainew[p->index].tbt = AI_BUS; // Bus-route

   185

		return;

   186

	}

   187

	if (_players_ainew[p->index].action == AI_ACTION_TRUCK_ROUTE &&

   188

			money > AI_MINIMUM_TRUCK_ROUTE_MONEY) {

   189

		if (GetFreeUnitNumber(VEH_ROAD) > _patches.max_roadveh) {

   190

			_players_ainew[p->index].action = AI_ACTION_NONE;

   191

			return;

   192

		}

   193

		_players_ainew[p->index].cargo = AI_NEED_CARGO;

   194

		_players_ainew[p->index].last_id = 0;

   195

		_players_ainew[p->index].state = AI_STATE_LOCATE_ROUTE;

   196

		_players_ainew[p->index].tbt = AI_TRUCK;

   197

		return;

   198

	}

   199

   200

	_players_ainew[p->index].state = AI_STATE_NOTHING;

   201

}

   202

   203

   204

static void AiNew_State_ActionDone(Player *p)

   205

{

   206

	_players_ainew[p->index].action = AI_ACTION_NONE;

   207

	_players_ainew[p->index].state = AI_STATE_NOTHING;

   208

}

   209

   210

   211

// Check if a city or industry is good enough to start a route there

   212

static bool AiNew_Check_City_or_Industry(Player *p, int ic, byte type)

   213

{

   214

	if (type == AI_CITY) {

   215

		const Town* t = GetTown(ic);

   216

		const Station* st;

   217

		uint count = 0;

   218

		int j = 0;

   219

   220

		// We don't like roadconstructions, don't even true such a city

   221

		if (t->road_build_months != 0) return false;

   222

   223

		// Check if the rating in a city is high enough

   224

		//  If not, take a chance if we want to continue

   225

		if (t->ratings[_current_player] < 0 && AI_CHANCE16(1, 4)) return false;

   226

   227

		if (t->max_pass - t->act_pass < AI_CHECKCITY_NEEDED_CARGO && !AI_CHANCE16(1, AI_CHECKCITY_CITY_CHANCE)) return false;

   228

   229

		// Check if we have build a station in this town the last 6 months

   230

		//  else we don't do it. This is done, because stat updates can be slow

   231

		//  and sometimes it takes up to 4 months before the stats are corectly.

   232

		//  This way we don't get 12 busstations in one city of 100 population ;)

   233

		FOR_ALL_STATIONS(st) {

   234

			// Do we own it?

   235

			if (st->owner == _current_player) {

   236

				// Are we talking busses?

   237

				if (_players_ainew[p->index].tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) != FACIL_BUS_STOP) continue;

   238

				// Is it the same city as we are in now?

   239

				if (st->town != t) continue;

   240

				// When was this station build?

   241

				if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false;

   242

				// Cound the amount of stations in this city that we own

   243

				count++;

   244

			} else {

   245

				// We do not own it, request some info about the station

   246

				//  we want to know if this station gets the same good. If so,

   247

				//  we want to know its rating. If it is too high, we are not going

   248

				//  to build there

   249

				if (!st->goods[CT_PASSENGERS].last_speed) continue;

   250

				// Is it around our city

   251

				if (DistanceManhattan(st->xy, t->xy) > 10) continue;

   252

				// It does take this cargo.. what is his rating?

   253

				if (st->goods[CT_PASSENGERS].rating < AI_CHECKCITY_CARGO_RATING) continue;

   254

				j++;

   255

				// When this is the first station, we build a second with no problem ;)

   256

				if (j == 1) continue;

   257

				// The rating is high.. second station...

   258

				//  a little chance that we still continue

   259

				//  But if there are 3 stations of this size, we never go on...

   260

				if (j == 2 && AI_CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue;

   261

				// We don't like this station :(

   262

				return false;

   263

			}

   264

		}

   265

   266

		// We are about to add one...

   267

		count++;

   268

		// Check if we the city can provide enough cargo for this amount of stations..

   269

		if (count * AI_CHECKCITY_CARGO_PER_STATION > t->max_pass) return false;

   270

   271

		// All check are okay, so we can build here!

   272

		return true;

   273

	}

   274

	if (type == AI_INDUSTRY) {

   275

		const Industry* i = GetIndustry(ic);

   276

		const Station* st;

   277

		int count = 0;

   278

		int j = 0;

   279

   280

		if (i->town != NULL && i->town->ratings[_current_player] < 0 && AI_CHANCE16(1, 4)) return false;

   281

   282

		// No limits on delevering stations!

   283

		//  Or for industry that does not give anything yet

   284

		if (i->produced_cargo[0] == CT_INVALID || i->last_month_production[0] == 0) return true;

   285

   286

		if (i->last_month_production[0] - i->last_month_transported[0] < AI_CHECKCITY_NEEDED_CARGO) return false;

   287

   288

		// Check if we have build a station in this town the last 6 months

   289

		//  else we don't do it. This is done, because stat updates can be slow

   290

		//  and sometimes it takes up to 4 months before the stats are corectly.

   291

		FOR_ALL_STATIONS(st) {

   292

			// Do we own it?

   293

			if (st->owner == _current_player) {

   294

				// Are we talking trucks?

   295

				if (_players_ainew[p->index].tbt == AI_TRUCK && (FACIL_TRUCK_STOP & st->facilities) != FACIL_TRUCK_STOP) continue;

   296

				// Is it the same city as we are in now?

   297

				if (st->town != i->town) continue;

   298

				// When was this station build?

   299

				if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false;

   300

				// Cound the amount of stations in this city that we own

   301

				count++;

   302

			} else {

   303

				// We do not own it, request some info about the station

   304

				//  we want to know if this station gets the same good. If so,

   305

				//  we want to know its rating. If it is too high, we are not going

   306

				//  to build there

   307

				if (i->produced_cargo[0] == CT_INVALID) continue;

   308

				// It does not take this cargo

   309

				if (!st->goods[i->produced_cargo[0]].last_speed) continue;

   310

				// Is it around our industry

   311

				if (DistanceManhattan(st->xy, i->xy) > 5) continue;

   312

				// It does take this cargo.. what is his rating?

   313

				if (st->goods[i->produced_cargo[0]].rating < AI_CHECKCITY_CARGO_RATING) continue;

   314

				j++;

   315

				// The rating is high.. a little chance that we still continue

   316

				//  But if there are 2 stations of this size, we never go on...

   317

				if (j == 1 && AI_CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue;

   318

				// We don't like this station :(

   319

				return false;

   320

			}

   321

		}

   322

   323

		// We are about to add one...

   324

		count++;

   325

		// Check if we the city can provide enough cargo for this amount of stations..

   326

		if (count * AI_CHECKCITY_CARGO_PER_STATION > i->last_month_production[0]) return false;

   327

   328

		// All check are okay, so we can build here!

   329

		return true;

   330

	}

   331

   332

	return true;

   333

}

   334

   335

   336

// This functions tries to locate a good route

   337

static void AiNew_State_LocateRoute(Player *p)

   338

{

   339

	assert(_players_ainew[p->index].state == AI_STATE_LOCATE_ROUTE);

   340

	// For now, we only support PASSENGERS, CITY and BUSSES

   341

   342

	// We don't have a route yet

   343

	if (_players_ainew[p->index].cargo == AI_NEED_CARGO) {

   344

		_players_ainew[p->index].new_cost = 0; // No cost yet

   345

		_players_ainew[p->index].temp = -1;

   346

		// Reset the counter

   347

		_players_ainew[p->index].counter = 0;

   348

   349

		_players_ainew[p->index].from_ic = -1;

   350

		_players_ainew[p->index].to_ic = -1;

   351

		if (_players_ainew[p->index].tbt == AI_BUS) {

   352

			// For now we only have a passenger route

   353

			_players_ainew[p->index].cargo = CT_PASSENGERS;

   354

   355

			// Find a route to cities

   356

			_players_ainew[p->index].from_type = AI_CITY;

   357

			_players_ainew[p->index].to_type = AI_CITY;

   358

		} else if (_players_ainew[p->index].tbt == AI_TRUCK) {

   359

			_players_ainew[p->index].cargo = AI_NO_CARGO;

   360

   361

			_players_ainew[p->index].from_type = AI_INDUSTRY;

   362

			_players_ainew[p->index].to_type = AI_INDUSTRY;

   363

		}

   364

   365

		// Now we are doing initing, we wait one tick

   366

		return;

   367

	}

   368

   369

	// Increase the counter and abort if it is taking too long!

   370

	_players_ainew[p->index].counter++;

   371

	if (_players_ainew[p->index].counter > AI_LOCATE_ROUTE_MAX_COUNTER) {

   372

		// Switch back to doing nothing!

   373

		_players_ainew[p->index].state = AI_STATE_NOTHING;

   374

		return;

   375

	}

   376

   377

	// We are going to locate a city from where we are going to connect

   378

	if (_players_ainew[p->index].from_ic == -1) {

   379

		if (_players_ainew[p->index].temp == -1) {

   380

			// First, we pick a random spot to search from

   381

			if (_players_ainew[p->index].from_type == AI_CITY) {

   382

				_players_ainew[p->index].temp = AI_RandomRange(GetMaxTownIndex() + 1);

   383

			} else {

   384

				_players_ainew[p->index].temp = AI_RandomRange(GetMaxIndustryIndex() + 1);

   385

			}

   386

		}

   387

   388

		if (!AiNew_Check_City_or_Industry(p, _players_ainew[p->index].temp, _players_ainew[p->index].from_type)) {

   389

			// It was not a valid city

   390

			//  increase the temp with one, and return. We will come back later here

   391

			//  to try again

   392

			_players_ainew[p->index].temp++;

   393

			if (_players_ainew[p->index].from_type == AI_CITY) {

   394

				if (_players_ainew[p->index].temp > GetMaxTownIndex()) _players_ainew[p->index].temp = 0;

   395

			} else {

   396

				if (_players_ainew[p->index].temp > GetMaxIndustryIndex()) _players_ainew[p->index].temp = 0;

   397

			}

   398

   399

			// Don't do an attempt if we are trying the same id as the last time...

   400

			if (_players_ainew[p->index].last_id == _players_ainew[p->index].temp) return;

   401

			_players_ainew[p->index].last_id = _players_ainew[p->index].temp;

   402

   403

			return;

   404

		}

   405

   406

		// We found a good city/industry, save the data of it

   407

		_players_ainew[p->index].from_ic = _players_ainew[p->index].temp;

   408

   409

		// Start the next tick with finding a to-city

   410

		_players_ainew[p->index].temp = -1;

   411

		return;

   412

	}

   413

   414

	// Find a to-city

   415

	if (_players_ainew[p->index].temp == -1) {

   416

		// First, we pick a random spot to search to

   417

		if (_players_ainew[p->index].to_type == AI_CITY) {

   418

			_players_ainew[p->index].temp = AI_RandomRange(GetMaxTownIndex() + 1);

   419

		} else {

   420

			_players_ainew[p->index].temp = AI_RandomRange(GetMaxIndustryIndex() + 1);

   421

		}

   422

	}

   423

   424

	// The same city is not allowed

   425

	// Also check if the city is valid

   426

	if (_players_ainew[p->index].temp != _players_ainew[p->index].from_ic && AiNew_Check_City_or_Industry(p, _players_ainew[p->index].temp, _players_ainew[p->index].to_type)) {

   427

		// Maybe it is valid..

   428

   429

		/* We need to know if they are not to far apart from eachother..

   430

		 * We do that by checking how much cargo we have to move and how long the

   431

		 * route is.

   432

		 */

   433

   434

		if (_players_ainew[p->index].from_type == AI_CITY && _players_ainew[p->index].tbt == AI_BUS) {

   435

			const Town* town_from = GetTown(_players_ainew[p->index].from_ic);

   436

			const Town* town_temp = GetTown(_players_ainew[p->index].temp);

   437

			uint distance = DistanceManhattan(town_from->xy, town_temp->xy);

   438

			int max_cargo;

   439

   440

			max_cargo  = town_from->max_pass + town_temp->max_pass;

   441

			max_cargo -= town_from->act_pass + town_temp->act_pass;

   442

   443

			// max_cargo is now the amount of cargo we can move between the two cities

   444

			// If it is more than the distance, we allow it

   445

			if (distance <= max_cargo * AI_LOCATEROUTE_BUS_CARGO_DISTANCE) {

   446

				// We found a good city/industry, save the data of it

   447

				_players_ainew[p->index].to_ic = _players_ainew[p->index].temp;

   448

				_players_ainew[p->index].state = AI_STATE_FIND_STATION;

   449

   450

				DEBUG(ai, 1, "[LocateRoute] found bus-route of %d tiles long (from %d to %d)",

   451

					distance,

   452

					_players_ainew[p->index].from_ic,

   453

					_players_ainew[p->index].temp

   454

				);

   455

   456

				_players_ainew[p->index].from_tile = 0;

   457

				_players_ainew[p->index].to_tile = 0;

   458

   459

				return;

   460

			}

   461

		} else if (_players_ainew[p->index].tbt == AI_TRUCK) {

   462

			const Industry* ind_from = GetIndustry(_players_ainew[p->index].from_ic);

   463

			const Industry* ind_temp = GetIndustry(_players_ainew[p->index].temp);

   464

			bool found = false;

   465

			int max_cargo = 0;

   466

			uint i;

   467

   468

			// TODO: in max_cargo, also check other cargo (beside [0])

   469

			// First we check if the from_ic produces cargo that this ic accepts

   470

			if (ind_from->produced_cargo[0] != CT_INVALID && ind_from->last_month_production[0] != 0) {

   471

				for (i = 0; i < lengthof(ind_temp->accepts_cargo); i++) {

   472

					if (ind_temp->accepts_cargo[i] == CT_INVALID) break;

   473

					if (ind_from->produced_cargo[0] == ind_temp->accepts_cargo[i]) {

   474

						// Found a compatible industry

   475

						max_cargo = ind_from->last_month_production[0] - ind_from->last_month_transported[0];

   476

						found = true;

   477

						_players_ainew[p->index].from_deliver = true;

   478

						_players_ainew[p->index].to_deliver = false;

   479

						break;

   480

					}

   481

				}

   482

			}

   483

			if (!found && ind_temp->produced_cargo[0] != CT_INVALID && ind_temp->last_month_production[0] != 0) {

   484

				// If not check if the current ic produces cargo that the from_ic accepts

   485

				for (i = 0; i < lengthof(ind_from->accepts_cargo); i++) {

   486

					if (ind_from->accepts_cargo[i] == CT_INVALID) break;

   487

					if (ind_from->produced_cargo[0] == ind_from->accepts_cargo[i]) {

   488

						// Found a compatbiel industry

   489

						found = true;

   490

						max_cargo = ind_temp->last_month_production[0] - ind_temp->last_month_transported[0];

   491

						_players_ainew[p->index].from_deliver = false;

   492

						_players_ainew[p->index].to_deliver = true;

   493

						break;

   494

					}

   495

				}

   496

			}

   497

			if (found) {

   498

				// Yeah, they are compatible!!!

   499

				// Check the length against the amount of goods

   500

				uint distance = DistanceManhattan(ind_from->xy, ind_temp->xy);

   501

   502

				if (distance > AI_LOCATEROUTE_TRUCK_MIN_DISTANCE &&

   503

						distance <= max_cargo * AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE) {