1

/*

     2

 * Next part is in Dutch, and only here for me, TrueLight, the maker of this new AI

     3

 */

     4

     5

// TODO: als iemand een vehicle stil zet op een weg waar de AI wil bouwen

     6

//         doet de AI helemaal niets meer

     7

// TODO: depot rondjes rijden stom iets dingus

     8

// TODO: jezelf afvragen of competitor_intelligence op niveau 2 wel meer geld moet opleverne...

     9

// TODO: als er iets in path komt, bouwt AI gewoon verder :(

    10

// TODO: mail routes

    11

    12

/*

    13

 * End of Dutch part

    14

 */

    15

    16

#include "stdafx.h"

    17

#include "ttd.h"

    18

#include "command.h"

    19

#include "ai.h"

    20

#include "town.h"

    21

#include "industry.h"

    22

#include "station.h"

    23

#include "engine.h"

    24

#include "gui.h"

    25

    26

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

    27

static void AiNew_State_FirstTime(Player *p) {

    28

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

    29

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

    30

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

    31

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

    32

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

    33

	// We first have to init some things

    34

    35

	if (_current_player == 1) {

    36

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

    37

	}

    38

    39

	// The PathFinder (AyStar)

    40

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

    41

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

    42

    p->ainew.path_info.start_tile_tl = 0;

    43

    p->ainew.path_info.start_tile_br = 0;

    44

    p->ainew.path_info.end_tile_tl = 0;

    45

    p->ainew.path_info.end_tile_br = 0;

    46

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

    47

    48

	p->ainew.idle = 0;

    49

	p->ainew.last_vehiclecheck_date = _date;

    50

    51

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

    52

	p->ainew.action = AI_ACTION_BUS_ROUTE;

    53

    54

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

    55

	p->ainew.state = AI_STATE_WAKE_UP;

    56

}

    57

    58

// This function just waste some time

    59

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

    60

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

    61

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

    62

//

    63

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

    64

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

    65

static void AiNew_State_Nothing(Player *p) {

    66

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

    67

    // If we are done idling, start over again

    68

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

    69

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

    70

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

    71

		// I mean.. the next tick ;)

    72

		p->ainew.state = AI_STATE_WAKE_UP;

    73

	}

    74

}

    75

    76

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

    77

//  Currently supported:

    78

//    - Make new route

    79

//    - Check route

    80

//    - Build HQ

    81

static void AiNew_State_WakeUp(Player *p) {

    82

    int32 money;

    83

    int c;

    84

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

    85

	// First, check if we have a HQ

    86

	if (p->location_of_house == 0) {

    87

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

    88

		// Random till we found a place for it!

    89

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

    90

		while (!AiNew_Build_CompanyHQ(p, (Random()&0xFFFF))) { }

    91

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

    92

		//  so we do not change any status

    93

		return;

    94

	}

    95

    96

	money = p->player_money - AI_MINIMUM_MONEY;

    97

    98

	// Let's pick an action!

    99

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

   100

		c = Random() & 0xFF;

   101

		if (p->current_loan > 0 && p->old_economy[1].income > AI_MINIMUM_INCOME_FOR_LOAN &&

   102

  			c < 10) {

   103

  			p->ainew.action = AI_ACTION_REPAY_LOAN;

   104

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

   105

			// Check all vehicles once in a while

   106

			p->ainew.action = AI_ACTION_CHECK_ALL_VEHICLES;

   107

			p->ainew.last_vehiclecheck_date = _date;

   108

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

   109

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

   110

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

   111

				if (c < 85) p->ainew.action = AI_ACTION_TRUCK_ROUTE;

   112

				else p->ainew.action = AI_ACTION_BUS_ROUTE;

   113

			}

   114

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

   115

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

   116

				p->ainew.action = AI_ACTION_TRAIN_ROUTE;

   117

			}

   118

		}*/

   119

   120

		p->ainew.counter = 0;

   121

	}

   122

   123

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

   124

		p->ainew.action = AI_ACTION_NONE;

   125

		return;

   126

	}

   127

   128

	if (_patches.ai_disable_veh_roadveh && (

   129

		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {

   130

		p->ainew.action = AI_ACTION_NONE;

   131

		return;

   132

	}

   133

   134

	if (_patches.ai_disable_veh_roadveh && (

   135

		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {

   136

		p->ainew.action = AI_ACTION_NONE;

   137

		return;

   138

	}

   139

   140

	if (p->ainew.action == AI_ACTION_REPAY_LOAN && money > AI_MINIMUM_LOAN_REPAY_MONEY) {

   141

		// We start repaying some money..

   142

		p->ainew.state = AI_STATE_REPAY_MONEY;

   143

		return;

   144

	}

   145

   146

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

   147

		p->ainew.state = AI_STATE_CHECK_ALL_VEHICLES;

   148

		return;

   149

	}

   150

   151

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

   152

	//  to build the route anyway..

   153

	if (p->ainew.action == AI_ACTION_BUS_ROUTE && money > AI_MINIMUM_BUS_ROUTE_MONEY) {

   154

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

   155

			p->ainew.action = AI_ACTION_NONE;

   156

			return;

   157

		}

   158

		p->ainew.cargo = AI_NEED_CARGO;

   159

		p->ainew.state = AI_STATE_LOCATE_ROUTE;

   160

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

   161

		return;

   162

	}

   163

	if (p->ainew.action == AI_ACTION_TRUCK_ROUTE && money > AI_MINIMUM_TRUCK_ROUTE_MONEY) {

   164

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

   165

			p->ainew.action = AI_ACTION_NONE;

   166

			return;

   167

		}

   168

		p->ainew.cargo = AI_NEED_CARGO;

   169

		p->ainew.last_id = 0;

   170

		p->ainew.state = AI_STATE_LOCATE_ROUTE;

   171

		p->ainew.tbt = AI_TRUCK;

   172

		return;

   173

	}

   174

   175

	p->ainew.state = AI_STATE_NOTHING;

   176

}

   177

   178

static void AiNew_State_ActionDone(Player *p) {

   179

    p->ainew.action = AI_ACTION_NONE;

   180

    p->ainew.state = AI_STATE_NOTHING;

   181

}

   182

   183

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

   184

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

   185

	if (type == AI_CITY) {

   186

		Town *t = DEREF_TOWN(ic);

   187

		Station *st;

   188

		int count = 0;

   189

		int j = 0;

   190

   191

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

   192

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

   193

   194

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

   195

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

   196

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

   197

   198

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

   199

   200

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

   201

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

   202

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

   203

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

   204

		FOR_ALL_STATIONS(st) {

   205

			// Is it an active station

   206

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

   207

			// Do we own it?

   208

			if (st->owner == _current_player) {

   209

				// Are we talking busses?

   210

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

   211

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

   212

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

   213

				// When was this station build?

   214

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

   215

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

   216

				count++;

   217

			} else {

   218

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

   219

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

   220

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

   221

				//  to build there

   222

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

   223

				// Is it around our city

   224

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

   225

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

   226

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

   227

				j++;

   228

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

   229

				if (j == 1) continue;

   230

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

   231

				//  a little chance that we still continue

   232

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

   233

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

   234

				// We don't like this station :(

   235

				return false;

   236

			}

   237

		}

   238

   239

		// We are about to add one...

   240

		count++;

   241

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

   242

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

   243

   244

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

   245

		return true;

   246

	}

   247

	if (type == AI_INDUSTRY) {

   248

		Industry *i = DEREF_INDUSTRY(ic);

   249

		Station *st;

   250

		int count = 0;

   251

		int j = 0;

   252

   253

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

   254

   255

		// No limits on delevering stations!

   256

		//  Or for industry that does not give anything yet

   257

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

   258

   259

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

   260

   261

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

   262

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

   263

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

   264

		FOR_ALL_STATIONS(st) {

   265

			// Is it an active station

   266

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

   267

   268

			// Do we own it?

   269

			if (st->owner == _current_player) {

   270

				// Are we talking trucks?

   271

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

   272

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

   273

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

   274

				// When was this station build?

   275

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

   276

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

   277

				count++;

   278

			} else {

   279

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

   280

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

   281

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

   282

				//  to build there

   283

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

   284

				// It does not take this cargo

   285

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

   286

				// Is it around our industry

   287

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

   288

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

   289

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

   290

				j++;

   291

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

   292

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

   293

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

   294

				// We don't like this station :(

   295

				return false;

   296

			}

   297

		}

   298

   299

		// We are about to add one...

   300

		count++;

   301

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

   302

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

   303

   304

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

   305

		return true;

   306

	}

   307

   308

	return true;

   309

}

   310

   311

// This functions tries to locate a good route

   312

static void AiNew_State_LocateRoute(Player *p) {

   313

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

   314

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

   315

   316

    // We don't have a route yet

   317

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

   318

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

   319

    	p->ainew.temp = -1;

   320

    	// Reset the counter

   321

    	p->ainew.counter = 0;

   322

   323

    	p->ainew.from_ic = -1;

   324

    	p->ainew.to_ic = -1;

   325

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

   326

   	    	// For now we only have a passenger route

   327

   	    	p->ainew.cargo = CT_PASSENGERS;

   328

   329

	    	// Find a route to cities

   330

	    	p->ainew.from_type = AI_CITY;

   331

	    	p->ainew.to_type = AI_CITY;

   332

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

   333

   	    	p->ainew.cargo = AI_NO_CARGO;

   334

   335

	    	p->ainew.from_type = AI_INDUSTRY;

   336

	    	p->ainew.to_type = AI_INDUSTRY;

   337

		}

   338

   339

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

   340

    	return;

   341

    }

   342

   343

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

   344

    p->ainew.counter++;

   345

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

   346

        // Switch back to doing nothing!

   347

    	p->ainew.state = AI_STATE_NOTHING;

   348

    	return;

   349

    }

   350

   351

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

   352

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

   353

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

   354

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

   355

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

   356

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

   357

       		else

   358

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

   359

        }

   360

   361

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

   362

    		// It was not a valid city

   363

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

   364

    		//  to try again

   365

    		p->ainew.temp++;

   366

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

   367

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

   368

        	} else {

   369

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

   370

        	}

   371

   372

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

   373

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

   374

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

   375

   376

    		return;

   377

    	}

   378

   379

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

   380

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

   381

   382

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

   383

    	p->ainew.temp = -1;

   384

    	return;

   385

    }

   386

   387

    // Find a to-city

   388

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

   389

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

   390

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

   391

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

   392

       	else

   393

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

   394

	}

   395

   396

	// The same city is not allowed

   397

	// Also check if the city is valid

   398

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

   399

   		// Maybe it is valid..

   400

   401

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

   402

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

   403

   		//   is.

   404

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

   				p->ainew.state = AI_STATE_FIND_STATION;

   414

   415

   				DEBUG(ai,1)("[AiNew - LocateRoute] Found bus-route of %d tiles long (from %d to %d)",GetTileDist(DEREF_TOWN(p->ainew.from_ic)->xy, DEREF_TOWN(p->ainew.temp)->xy), p->ainew.from_ic, p->ainew.temp);

   416

   417

   				p->ainew.from_tile = 0;

   418

   				p->ainew.to_tile = 0;

   419

   420

   				return;

   421

   			}

   422

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

   423

         	bool found = false;

   424

         	int max_cargo = 0;

   425

         	int i;

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

						// Found a compatbiel industry

   433

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

   434

						found = true;

   435

	   					p->ainew.from_deliver = true;

   436

	   					p->ainew.to_deliver = false;

   437

	       				break;

   438

	       			}

   439

	       		}

   440

   			}

   441

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

   442

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

   443

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

   444

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

   445

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

   446

						// Found a compatbiel industry

   447

						found = true;

   448

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

   449

	   					p->ainew.from_deliver = false;

   450

	   					p->ainew.to_deliver = true;

   451

	       				break;

   452

	       			}

   453

	   			}

   454

   			}

   455

   			if (found) {

   456

   				// Yeah, they are compatible!!!

   457

   				// Check the length against the amount of goods

   458

   				if (GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy) > AI_LOCATEROUTE_TRUCK_MIN_DISTANCE &&

   459

       				GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE) {

   460

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

   461

	   				if (p->ainew.from_deliver) {

   462

	   					p->ainew.cargo = DEREF_INDUSTRY(p->ainew.from_ic)->produced_cargo[0];

   463

	   				} else {

   464

   						p->ainew.cargo = DEREF_INDUSTRY(p->ainew.temp)->produced_cargo[0];

   465

   					}

   466

	   				p->ainew.state = AI_STATE_FIND_STATION;

   467

   468

	   				DEBUG(ai,1)("[AiNew - LocateRoute] Found truck-route of %d tiles long (from %d to %d)",GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy), p->ainew.from_ic, p->ainew.temp);

   469

   470

	   				p->ainew.from_tile = 0;

   471

	   				p->ainew.to_tile = 0;

   472

   473

	   				return;

   474

	   			}

   475

   			}

   476

   		}

   477

   	}

   478

   479

    // It was not a valid city

   480

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

   481

   	//  to try again

   482

   	p->ainew.temp++;

   483

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

   484

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

   485

    } else {

   486

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

   487

    }

   488

   489

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

   490

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

   491

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

   492