1

/* $Id: ai_new.c 2891 2005-08-26 20:26:34Z tron $ */

     2

     3

/*

     4

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

     5

 *   Too bad it never left alpha-stage, and it is considered dead in his current form.

     6

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

     7

 *   are designing a whole new AI-system that allows us to create AIs easier and without

     8

 *   all the fuzz we encountered while I was working on this AI. By the time that system

     9

 *   is finished, you can expect that this AI will dissapear, because it is pretty

    10

 *   obselete and bad programmed.

    11

 *

    12

 * In the meanwhile I wish you all much fun with this AI; if you are interested as

    13

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

    14

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

    15

 *

    16

 *  -- TrueLight :: 2005-09-01

    17

 */

    18

    19

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

    20

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

    21

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

    22

#include "../../functions.h"

    23

#include "../../table/strings.h"

    24

#include "../../map.h"

    25

#include "../../tile.h"

    26

#include "../../command.h"

    27

#include "trolly.h"

    28

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

    29

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

    30

#include "../../station.h"

    31

#include "../../engine.h"

    32

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

    33

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

    34

    35

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

    36

static void AiNew_State_FirstTime(Player *p)

    37

{

    38

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

    39

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

    40

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

    41

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

    42

	assert(p->ainew.state == AI_STATE_FIRST_TIME);

    43

	// We first have to init some things

    44

    45

	if (_current_player == 1) {

    46

		ShowErrorMessage(-1, TEMP_AI_IN_PROGRESS, 0, 0);

    47

	}

    48

    49

	// The PathFinder (AyStar)

    50

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

    51

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

    52

	p->ainew.path_info.start_tile_tl = 0;

    53

	p->ainew.path_info.start_tile_br = 0;

    54

	p->ainew.path_info.end_tile_tl = 0;

    55

	p->ainew.path_info.end_tile_br = 0;

    56

	p->ainew.pathfinder = new_AyStar_AiPathFinder(12, &p->ainew.path_info);

    57

    58

	p->ainew.idle = 0;

    59

	p->ainew.last_vehiclecheck_date = _date;

    60

    61

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

    62

	p->ainew.action = AI_ACTION_BUS_ROUTE;

    63

    64

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

    65

	p->ainew.state = AI_STATE_WAKE_UP;

    66

}

    67

    68

    69

// This function just waste some time

    70

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

    71

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

    72

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

    73

//

    74

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

    75

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

    76

static void AiNew_State_Nothing(Player *p)

    77

{

    78

	assert(p->ainew.state == AI_STATE_NOTHING);

    79

	// If we are done idling, start over again

    80

	if (p->ainew.idle == 0) p->ainew.idle = RandomRange(DAY_TICKS * 2) + DAY_TICKS;

    81

	if (--p->ainew.idle == 0) {

    82

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

    83

		// I mean.. the next tick ;)

    84

		p->ainew.state = AI_STATE_WAKE_UP;

    85

	}

    86

}

    87

    88

    89

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

    90

//  Currently supported:

    91

//    - Make new route

    92

//    - Check route

    93

//    - Build HQ

    94

static void AiNew_State_WakeUp(Player *p)

    95

{

    96

	int32 money;

    97

	int c;

    98

	assert(p->ainew.state == AI_STATE_WAKE_UP);

    99

	// First, check if we have a HQ

   100

	if (p->location_of_house == 0) {

   101

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

   102

		// Random till we found a place for it!

   103

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

   104

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

   105

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

   106

		//  so we do not change any status

   107

		return;

   108

	}

   109

   110

	money = p->player_money - AI_MINIMUM_MONEY;

   111

   112

	// Let's pick an action!

   113

	if (p->ainew.action == AI_ACTION_NONE) {

   114

		c = Random() & 0xFF;

   115

		if (p->current_loan > 0 &&

   116

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

   117

				c < 10) {

   118

			p->ainew.action = AI_ACTION_REPAY_LOAN;

   119

		} else if (p->ainew.last_vehiclecheck_date + AI_DAYS_BETWEEN_VEHICLE_CHECKS < _date) {

   120

			// Check all vehicles once in a while

   121

			p->ainew.action = AI_ACTION_CHECK_ALL_VEHICLES;

   122

			p->ainew.last_vehiclecheck_date = _date;

   123

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

   124

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

   125

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

   126

				if (c < 85)

   127

					p->ainew.action = AI_ACTION_TRUCK_ROUTE;

   128

				else

   129

					p->ainew.action = AI_ACTION_BUS_ROUTE;

   130

			}

   131

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

   132

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

   133

				p->ainew.action = AI_ACTION_TRAIN_ROUTE;

   134

			}

   135

		}*/

   136

   137

		p->ainew.counter = 0;

   138

	}

   139

   140

	if (p->ainew.counter++ > AI_MAX_TRIES_FOR_SAME_ROUTE) {

   141

		p->ainew.action = AI_ACTION_NONE;

   142

		return;

   143

	}

   144

   145

	if (_patches.ai_disable_veh_roadveh && (

   146

				p->ainew.action == AI_ACTION_BUS_ROUTE ||

   147

				p->ainew.action == AI_ACTION_TRUCK_ROUTE

   148

			)) {

   149

		p->ainew.action = AI_ACTION_NONE;

   150

		return;

   151

	}

   152

   153

	if (_patches.ai_disable_veh_roadveh && (

   154

				p->ainew.action == AI_ACTION_BUS_ROUTE ||

   155

				p->ainew.action == AI_ACTION_TRUCK_ROUTE

   156

			)) {

   157

		p->ainew.action = AI_ACTION_NONE;

   158

		return;

   159

	}

   160

   161

	if (p->ainew.action == AI_ACTION_REPAY_LOAN &&

   162

			money > AI_MINIMUM_LOAN_REPAY_MONEY) {

   163

		// We start repaying some money..

   164

		p->ainew.state = AI_STATE_REPAY_MONEY;

   165

		return;

   166

	}

   167

   168

	if (p->ainew.action == AI_ACTION_CHECK_ALL_VEHICLES) {

   169

		p->ainew.state = AI_STATE_CHECK_ALL_VEHICLES;

   170

		return;

   171

	}

   172

   173

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

   174

	//  to build the route anyway..

   175

	if (p->ainew.action == AI_ACTION_BUS_ROUTE &&

   176

			money > AI_MINIMUM_BUS_ROUTE_MONEY) {

   177

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

   178

			p->ainew.action = AI_ACTION_NONE;

   179

			return;

   180

		}

   181

		p->ainew.cargo = AI_NEED_CARGO;

   182

		p->ainew.state = AI_STATE_LOCATE_ROUTE;

   183

		p->ainew.tbt = AI_BUS; // Bus-route

   184

		return;

   185

	}

   186

	if (p->ainew.action == AI_ACTION_TRUCK_ROUTE &&

   187

			money > AI_MINIMUM_TRUCK_ROUTE_MONEY) {

   188

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

   189

			p->ainew.action = AI_ACTION_NONE;

   190

			return;

   191

		}

   192

		p->ainew.cargo = AI_NEED_CARGO;

   193

		p->ainew.last_id = 0;

   194

		p->ainew.state = AI_STATE_LOCATE_ROUTE;

   195

		p->ainew.tbt = AI_TRUCK;

   196

		return;

   197

	}

   198

   199

	p->ainew.state = AI_STATE_NOTHING;

   200

}

   201

   202

   203

static void AiNew_State_ActionDone(Player *p)

   204

{

   205

	p->ainew.action = AI_ACTION_NONE;

   206

	p->ainew.state = AI_STATE_NOTHING;

   207

}

   208

   209

   210

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

   211

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

   212

{

   213

	if (type == AI_CITY) {

   214

		Town *t = GetTown(ic);

   215

		Station *st;

   216

		uint count = 0;

   217

		int j = 0;

   218

   219

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

   220

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

   221

   222

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

   223

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

   224

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

   225

   226

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

   227

   228

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

   229

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

   230

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

   231

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

   232

		FOR_ALL_STATIONS(st) {

   233

			// Is it an active station

   234

			if (st->xy == 0) continue;

   235

			// Do we own it?

   236

			if (st->owner == _current_player) {

   237

				// Are we talking busses?

   238

				if (p->ainew.tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) != FACIL_BUS_STOP) continue;

   239

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

   240

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

   241

				// When was this station build?

   242

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

   243

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

   244

				count++;

   245

			} else {

   246

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

   247

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

   248

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

   249

				//  to build there

   250

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

   251

				// Is it around our city

   252

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

   253

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

   254

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

   255

				j++;

   256

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

   257

				if (j == 1) continue;

   258

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

   259

				//  a little chance that we still continue

   260

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

   261

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

   262

				// We don't like this station :(

   263

				return false;

   264

			}

   265

		}

   266

   267

		// We are about to add one...

   268

		count++;

   269

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

   270

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

   271

   272

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

   273

		return true;

   274

	}

   275

	if (type == AI_INDUSTRY) {

   276

		Industry *i = GetIndustry(ic);

   277

		Station *st;

   278

		int count = 0;

   279

		int j = 0;

   280

   281

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

   282

   283

		// No limits on delevering stations!

   284

		//  Or for industry that does not give anything yet

   285

		if (i->produced_cargo[0] == 0xFF || i->total_production[0] == 0) return true;

   286

   287

		if (i->total_production[0] - i->total_transported[0] < AI_CHECKCITY_NEEDED_CARGO) return false;

   288

   289

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

   290

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

   291

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

   292

		FOR_ALL_STATIONS(st) {

   293

			// Is it an active station

   294

			if (st->xy == 0) continue;

   295

   296

			// Do we own it?

   297

			if (st->owner == _current_player) {

   298

				// Are we talking trucks?

   299

				if (p->ainew.tbt == AI_TRUCK && (FACIL_TRUCK_STOP & st->facilities) != FACIL_TRUCK_STOP) continue;

   300

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

   301

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

   302

				// When was this station build?

   303

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

   304

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

   305

				count++;

   306

			} else {

   307

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

   308

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

   309

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

   310

				//  to build there

   311

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

   312

				// It does not take this cargo

   313

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

   314

				// Is it around our industry

   315

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

   316

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

   317

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

   318

				j++;

   319

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

   320

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

   321

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

   322

				// We don't like this station :(

   323

				return false;

   324

			}

   325

		}

   326

   327

		// We are about to add one...

   328

		count++;

   329

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

   330

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

   331

   332

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

   333

		return true;

   334

	}

   335

   336

	return true;

   337

}

   338

   339

   340

// This functions tries to locate a good route

   341

static void AiNew_State_LocateRoute(Player *p)

   342

{

   343

	assert(p->ainew.state == AI_STATE_LOCATE_ROUTE);

   344

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

   345

   346

	// We don't have a route yet

   347

	if (p->ainew.cargo == AI_NEED_CARGO) {

   348

		p->ainew.new_cost = 0; // No cost yet

   349

		p->ainew.temp = -1;

   350

		// Reset the counter

   351

		p->ainew.counter = 0;

   352

   353

		p->ainew.from_ic = -1;

   354

		p->ainew.to_ic = -1;

   355

		if (p->ainew.tbt == AI_BUS) {

   356

			// For now we only have a passenger route

   357

			p->ainew.cargo = CT_PASSENGERS;

   358

   359

			// Find a route to cities

   360

			p->ainew.from_type = AI_CITY;

   361

			p->ainew.to_type = AI_CITY;

   362

		} else if (p->ainew.tbt == AI_TRUCK) {

   363

			p->ainew.cargo = AI_NO_CARGO;

   364

   365

			p->ainew.from_type = AI_INDUSTRY;

   366

			p->ainew.to_type = AI_INDUSTRY;

   367

		}

   368

   369

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

   370

		return;

   371

	}

   372

   373

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

   374

	p->ainew.counter++;

   375

	if (p->ainew.counter > AI_LOCATE_ROUTE_MAX_COUNTER) {

   376

		// Switch back to doing nothing!

   377

		p->ainew.state = AI_STATE_NOTHING;

   378

		return;

   379

	}

   380

   381

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

   382

	if (p->ainew.from_ic == -1) {

   383

		if (p->ainew.temp == -1) {

   384

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

   385

			if (p->ainew.from_type == AI_CITY)

   386

				p->ainew.temp = RandomRange(_total_towns);

   387

			else

   388

				p->ainew.temp = RandomRange(_total_industries);

   389

		}

   390

   391

		if (!AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.from_type)) {

   392

			// It was not a valid city

   393

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

   394

			//  to try again

   395

			p->ainew.temp++;

   396

			if (p->ainew.from_type == AI_CITY) {

   397

				if (p->ainew.temp >= (int)_total_towns) p->ainew.temp = 0;

   398

			} else {

   399

				if (p->ainew.temp >= _total_industries) p->ainew.temp = 0;

   400

			}

   401

   402

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

   403

			if (p->ainew.last_id == p->ainew.temp) return;

   404

			p->ainew.last_id = p->ainew.temp;

   405

   406

			return;

   407

		}

   408

   409

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

   410

		p->ainew.from_ic = p->ainew.temp;

   411

   412

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

   413

		p->ainew.temp = -1;

   414

		return;

   415

	}

   416

   417

	// Find a to-city

   418

	if (p->ainew.temp == -1) {

   419

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

   420

		if (p->ainew.to_type == AI_CITY)

   421

			p->ainew.temp = RandomRange(_total_towns);

   422

		else

   423

			p->ainew.temp = RandomRange(_total_industries);

   424

	}

   425

   426

	// The same city is not allowed

   427

	// Also check if the city is valid

   428

	if (p->ainew.temp != p->ainew.from_ic && AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.to_type)) {

   429

		// Maybe it is valid..

   430

   431

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

   432

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

   433

		//   is.

   434

   435

		if (p->ainew.from_type == AI_CITY && p->ainew.tbt == AI_BUS) {

   436

			int max_cargo = GetTown(p->ainew.from_ic)->max_pass + GetTown(p->ainew.temp)->max_pass;

   437

			max_cargo -= GetTown(p->ainew.from_ic)->act_pass + GetTown(p->ainew.temp)->act_pass;

   438

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

   439

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

   440

			if (DistanceManhattan(GetTown(p->ainew.from_ic)->xy, GetTown(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_BUS_CARGO_DISTANCE) {

   441

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

   442

				p->ainew.to_ic = p->ainew.temp;

   443

				p->ainew.state = AI_STATE_FIND_STATION;

   444

   445

				DEBUG(ai,1)(

   446

					"[AiNew - LocateRoute] Found bus-route of %d tiles long (from %d to %d)",

   447

					DistanceManhattan(GetTown(p->ainew.from_ic)->xy, GetTown(p->ainew.temp)->xy),

   448

					p->ainew.from_ic,

   449

					p->ainew.temp

   450

				);

   451

   452

				p->ainew.from_tile = 0;

   453

				p->ainew.to_tile = 0;

   454

   455

				return;

   456

			}

   457

		} else if (p->ainew.tbt == AI_TRUCK) {

   458

			bool found = false;

   459

			int max_cargo = 0;

   460

			int i;

   461

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

   462

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

   463

			if (GetIndustry(p->ainew.from_ic)->produced_cargo[0] != 0xFF && GetIndustry(p->ainew.from_ic)->total_production[0] != 0) {

   464

				for (i=0;i<3;i++) {

   465

					if (GetIndustry(p->ainew.temp)->accepts_cargo[i] == 0xFF) break;

   466

					if (GetIndustry(p->ainew.from_ic)->produced_cargo[0] == GetIndustry(p->ainew.temp)->accepts_cargo[i]) {

   467

						// Found a compatbiel industry

   468

						max_cargo = GetIndustry(p->ainew.from_ic)->total_production[0] - GetIndustry(p->ainew.from_ic)->total_transported[0];

   469

						found = true;

   470

						p->ainew.from_deliver = true;

   471

						p->ainew.to_deliver = false;

   472

						break;

   473

					}

   474

				}

   475

			}

   476

			if (!found && GetIndustry(p->ainew.temp)->produced_cargo[0] != 0xFF && GetIndustry(p->ainew.temp)->total_production[0] != 0) {

   477

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

   478

				for (i=0;i<3;i++) {

   479

					if (GetIndustry(p->ainew.from_ic)->accepts_cargo[i] == 0xFF) break;

   480

					if (GetIndustry(p->ainew.temp)->produced_cargo[0] == GetIndustry(p->ainew.from_ic)->accepts_cargo[i]) {

   481

						// Found a compatbiel industry

   482

						found = true;

   483

						max_cargo = GetIndustry(p->ainew.temp)->total_production[0] - GetIndustry(p->ainew.from_ic)->total_transported[0];

   484

						p->ainew.from_deliver = false;

   485

						p->ainew.to_deliver = true;

   486

						break;

   487

					}

   488

				}