1

/* $Id$ */

     2

     3

/**

     4

 * @file trolly.cpp Implementation of the trolly AI.

     5

 *

     6

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

     7

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

     8

 * current form.

     9

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

    10

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

    11

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

    12

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

    13

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

    14

 *

    15

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

    16

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

    17

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

    18

 *

    19

 *  -- TrueLight :: 2005-09-01

    20

 */

    21

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

#include "trolly.h"

    29

#include "../../depot_base.h"

    30

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

    31

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

    32

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

    33

#include "../../engine_func.h"

    34

#include "../../engine_base.h"

    35

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

    36

#include "../../depot_base.h"

    37

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

    38

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

    39

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

    40

#include "../ai.h"

    41

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

    42

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

    43

    44

#include "table/strings.h"

    45

    47

    48

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

    50

{

    51

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

    52

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

    53

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

    54

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

    56

	// We first have to init some things

    57

    59

    60

	// The PathFinder (AyStar)

    61

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

    62

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

    68

    71

    72

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

    74

    75

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

    77

}

    78

    79

    80

// This function just waste some time

    81

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

    82

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

    83

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

    84

//

    85

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

    86

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

    88

{

    90

	// If we are done idling, start over again

    93

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

    94

		// I mean.. the next tick ;)

    96

	}

    97

}

    98

    99

   100

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

   101

//  Currently supported:

   102

//    - Make new route

   103

//    - Check route

   104

//    - Build HQ

   106

{

   108

	// First, check if we have a HQ

   110

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

   111

		// Random till we found a place for it!

   112

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

   114

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

   115

		//  so we do not change any status

   116

		return;

   117

	}

   118

   120

   121

	// Let's pick an action!

   129

			// Check all vehicles once in a while

   133

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

   134

			if (GetFreeUnitNumber(VEH_ROAD) <= _settings_game.vehicle.max_roadveh) {

   137

				} else {

   139

				}

   140

			}

   141

#if 0

   143

			if (GetFreeUnitNumber(VEH_TRAIN) <= _settings_game.vehicle.max_trains) {

   145

			}

   146

#endif

   147

		}

   148

   150

	}

   151

   154

		return;

   155

	}

   156

   157

	if (_settings_game.ai.ai_disable_veh_roadveh && (

   160

			)) {

   162

		return;

   163

	}

   164

   166

			money > AI_MINIMUM_LOAN_REPAY_MONEY) {

   167

		// We start repaying some money..

   169

		return;

   170

	}

   171

   174

		return;

   175

	}

   176

   177

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

   178

	//  to build the route anyway..

   180

			money > AI_MINIMUM_BUS_ROUTE_MONEY) {

   181

		if (GetFreeUnitNumber(VEH_ROAD) > _settings_game.vehicle.max_roadveh) {

   183

			return;

   184

		}

   188

		return;

   189

	}

   191

			money > AI_MINIMUM_TRUCK_ROUTE_MONEY) {

   192

		if (GetFreeUnitNumber(VEH_ROAD) > _settings_game.vehicle.max_roadveh) {

   194

			return;

   195

		}

   200

		return;

   201

	}

   202

   204

}

   205

   206

   208

{

   211

}

   212

   213

   214

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

   216

{

   217

	if (type == AI_CITY) {

   218

		const Town* t = GetTown(ic);

   219

		const Station* st;

   220

		uint count = 0;

   221

		int j = 0;

   222

   223

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

   224

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

   225

   226

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

   227

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

   229

   230

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

   231

   232

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

   233

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

   234

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

   235

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

   236

		FOR_ALL_STATIONS(st) {

   237

			// Do we own it?

   239

				// Are we talking busses?

   241

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

   242

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

   243

				// When was this station build?

   244

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

   245

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

   246

				count++;

   247

			} else {

   248

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

   249

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

   250

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

   251

				//  to build there

   252

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

   253

				// Is it around our city

   254

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

   255

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

   256

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

   257

				j++;

   258

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

   259

				if (j == 1) continue;

   260

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

   261

				//  a little chance that we still continue

   262

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

   263

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

   264

				// We don't like this station :(

   265

				return false;

   266

			}

   267

		}

   268

   269

		// We are about to add one...

   270

		count++;

   271

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

   272

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

   273

   274

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

   275

		return true;

   276

	}

   277

	if (type == AI_INDUSTRY) {

   278

		const Industry* i = GetIndustry(ic);

   279

		const Station* st;

   280

		int count = 0;

   281

		int j = 0;

   282

   284

   285

		// No limits on delevering stations!

   286

		//  Or for industry that does not give anything yet

   287

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

   288

   289

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

   290

   291

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

   292

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

   293

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

   294

		FOR_ALL_STATIONS(st) {

   295

			// Do we own it?

   297

				// Are we talking trucks?

   299

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

   300

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

   301

				// When was this station build?

   302

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

   303

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

   304

				count++;

   305

			} else {

   306

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

   307

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

   308

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

   309

				//  to build there

   310

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

   311

				// It does not take this cargo

   312

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

   313

				// Is it around our industry

   314

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

   315

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

   316

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

   317

				j++;

   318

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

   319

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

   320

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

   321

				// We don't like this station :(

   322

				return false;

   323

			}

   324

		}

   325

   326

		// We are about to add one...

   327

		count++;

   328

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

   329

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

   330

   331

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

   332

		return true;

   333

	}

   334

   335

	return true;

   336

}

   337

   338

   339

// This functions tries to locate a good route

   341

{

   343

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

   344

   345

	// We don't have a route yet

   349

		// Reset the counter

   351

   355

			// For now we only have a passenger route

   357

   358

			// Find a route to cities

   363

   366

		}

   367

   368

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

   369

		return;

   370

	}

   371

   372

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

   375

		// Switch back to doing nothing!

   377

		return;

   378

	}

   379

   380

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

   383

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

   386

			} else {

   388

			}

   389

		}

   390

   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

   398

			} else {

   400

			}

   401

   402

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

   405

   406

			return;

   407

		}

   408

   409

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

   411

   412

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

   414

		return;

   415

	}

   416

   417

	// Find a to-city

   419

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

   422

		} else {

   424

		}

   425

	}

   426

   427

	// The same city is not allowed

   428

	// Also check if the city is valid

   430

		// Maybe it is valid..

   431

   432

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

   433

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

   434

		 * route is.

   435

		 */

   436

   440

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

   441

			int max_cargo;

   442

   443

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

   444

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

   445

   446

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

   447

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

   448

			if (distance <= max_cargo * AI_LOCATEROUTE_BUS_CARGO_DISTANCE) {

   449

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

   452

   453

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

   454

					distance,

   457

				);

   458

   461

   462

				return;

   463

			}

   467

			bool found = false;

   468

			int max_cargo = 0;

   469

			uint i;

   470

   471

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

   472

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

   473

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

   474

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

   475

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

   476

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

   477

						// Found a compatible industry

   478

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

   479

						found = true;

   482

						break;

   483

					}

   484

				}

   485

			}

   486

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

   487

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

   488

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

   489

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

   490

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

   491

						// Found a compatbiel industry

   492

						found = true;

   493

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

   496

						break;

   497

					}

   498

				}

   499

			}

   500

			if (found) {

   501