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

    50

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

    51

	p->ainew.action = AI_ACTION_BUS_ROUTE;

    52

    53

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

    54

	p->ainew.state = AI_STATE_WAKE_UP;

    55

}

    56

    57

// This function just waste some time

    58

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

    59

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

    60

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

    61

//

    62

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

    63

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

    64

static void AiNew_State_Nothing(Player *p) {

    65

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

    66

    // If we are done idling, start over again

    67

    // There go 74 ticks in a day

    68

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

    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 (c < 100 && !_patches.ai_disable_veh_roadveh) {

   105

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

   106

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

   107

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

   108

				else p->ainew.action = AI_ACTION_BUS_ROUTE;

   109

			}

   110

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

   111

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

   112

				p->ainew.action = AI_ACTION_TRAIN_ROUTE;

   113

			}

   114

		}*/

   115

	}

   116

   117

	if (_patches.ai_disable_veh_roadveh && (

   118

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

   119

		p->ainew.action = AI_ACTION_NONE;

   120

		return;

   121

	}

   122

   123

	if (_patches.ai_disable_veh_roadveh && (

   124

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

   125

		p->ainew.action = AI_ACTION_NONE;

   126

		return;

   127

	}

   128

   129

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

   130

		// We start repaying some money..

   131

		p->ainew.state = AI_STATE_REPAY_MONEY;

   132

		return;

   133

	}

   134

   135

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

   136

	//  to build the route anyway..

   137

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

   138

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

   139

			p->ainew.action = AI_ACTION_NONE;

   140

			return;

   141

		}

   142

		p->ainew.cargo = AI_NEED_CARGO;

   143

		p->ainew.state = AI_STATE_LOCATE_ROUTE;

   144

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

   145

		return;

   146

	}

   147

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

   148

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

   149

			p->ainew.action = AI_ACTION_NONE;

   150

			return;

   151

		}

   152

		p->ainew.cargo = AI_NEED_CARGO;

   153

		p->ainew.last_id = 0;

   154

		p->ainew.state = AI_STATE_LOCATE_ROUTE;

   155

		p->ainew.tbt = AI_TRUCK;

   156

		return;

   157

	}

   158

   159

	p->ainew.state = AI_STATE_NOTHING;

   160

}

   161

   162

static void AiNew_State_ActionDone(Player *p) {

   163

    p->ainew.action = AI_ACTION_NONE;

   164

    p->ainew.state = AI_STATE_NOTHING;

   165

}

   166

   167

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

   168

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

   169

	if (type == AI_CITY) {

   170

		Town *t = DEREF_TOWN(ic);

   171

		Station *st;

   172

		int count = 0;

   173

		int j = 0;

   174

   175

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

   176

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

   177

   178

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

   179

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

   180

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

   181

   182

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

   183

   184

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

   185

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

   186

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

   187

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

   188

		FOR_ALL_STATIONS(st) {

   189

			// Is it an active station

   190

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

   191

			// Do we own it?

   192

			if (st->owner == _current_player) {

   193

				// Are we talking busses?

   194

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

   195

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

   196

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

   197

				// When was this station build?

   198

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

   199

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

   200

				count++;

   201

			} else {

   202

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

   203

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

   204

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

   205

				//  to build there

   206

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

   207

				// Is it around our city

   208

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

   209

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

   210

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

   211

				j++;

   212

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

   213

				if (j == 1) continue;

   214

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

   215

				//  a little chance that we still continue

   216

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

   217

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

   218

				// We don't like this station :(

   219

				return false;

   220

			}

   221

		}

   222

   223

		// We are about to add one...

   224

		count++;

   225

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

   226

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

   227

   228

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

   229

		return true;

   230

	}

   231

	if (type == AI_INDUSTRY) {

   232

		Industry *i = DEREF_INDUSTRY(ic);

   233

		Station *st;

   234

		int count = 0;

   235

		int j = 0;

   236

   237

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

   238

   239

		// No limits on delevering stations!

   240

		//  Or for industry that does not give anything yet

   241

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

   242

   243

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

   244

   245

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

   246

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

   247

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

   248

		FOR_ALL_STATIONS(st) {

   249

			// Is it an active station

   250

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

   251

   252

			// Do we own it?

   253

			if (st->owner == _current_player) {

   254

				// Are we talking trucks?

   255

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

   256

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

   257

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

   258

				// When was this station build?

   259

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

   260

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

   261

				count++;

   262

			} else {

   263

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

   264

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

   265

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

   266

				//  to build there

   267

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

   268

				// It does not take this cargo

   269

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

   270

				// Is it around our industry

   271

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

   272

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

   273

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

   274

				j++;

   275

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

   276

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

   277

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

   278

				// We don't like this station :(

   279

				return false;

   280

			}

   281

		}

   282

   283

		// We are about to add one...

   284

		count++;

   285

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

   286

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

   287

   288

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

   289

		return true;

   290

	}

   291

   292

	return true;

   293

}

   294

   295

// This functions tries to locate a good route

   296

static void AiNew_State_LocateRoute(Player *p) {

   297

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

   298

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

   299

   300

    // We don't have a route yet

   301

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

   302

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

   303

    	p->ainew.temp = -1;

   304

    	// Reset the counter

   305

    	p->ainew.counter = 0;

   306

   307

    	p->ainew.from_ic = -1;

   308

    	p->ainew.to_ic = -1;

   309

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

   310

   	    	// For now we only have a passenger route

   311

   	    	p->ainew.cargo = CT_PASSENGERS;

   312

   313

	    	// Find a route to cities

   314

	    	p->ainew.from_type = AI_CITY;

   315

	    	p->ainew.to_type = AI_CITY;

   316

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

   317

   	    	p->ainew.cargo = AI_NO_CARGO;

   318

   319

	    	p->ainew.from_type = AI_INDUSTRY;

   320

	    	p->ainew.to_type = AI_INDUSTRY;

   321

		}

   322

   323

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

   324

    	return;

   325

    }

   326

   327

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

   328

    p->ainew.counter++;

   329

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

   330

        // Switch back to doing nothing!

   331

    	p->ainew.state = AI_STATE_NOTHING;

   332

    	return;

   333

    }

   334

   335

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

   336

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

   337

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

   338

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

   339

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

   340

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

   341

       		else

   342

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

   343

        }

   344

   345

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

   346

    		// It was not a valid city

   347

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

   348

    		//  to try again

   349

    		p->ainew.temp++;

   350

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

   351

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

   352

        	} else {

   353

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

   354

        	}

   355

   356

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

   357

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

   358

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

   359

   360

    		return;

   361

    	}

   362

   363

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

   364

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

   365

   366

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

   367

    	p->ainew.temp = -1;

   368

    	return;

   369

    }

   370

   371

    // Find a to-city

   372

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

   373

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

   374

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

   375

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

   376

       	else

   377

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

   378

	}

   379

   380

	// The same city is not allowed

   381

	// Also check if the city is valid

   382

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

   383

   		// Maybe it is valid..

   384

   385

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

   386

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

   387

   		//   is.

   388

   389

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

   390

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

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

   				p->ainew.state = AI_STATE_FIND_STATION;

   398

   399

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

   400

   401

   				p->ainew.from_tile = 0;

   402

   				p->ainew.to_tile = 0;

   403

   404

   				return;

   405

   			}

   406

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

   407

         	bool found = false;

   408

         	int max_cargo = 0;

   409

         	int i;

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

						// Found a compatbiel industry

   417

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

   418

						found = true;

   419

	   					p->ainew.from_deliver = true;

   420

	   					p->ainew.to_deliver = false;

   421

	       				break;

   422

	       			}

   423

	       		}

   424

   			}

   425

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

   426

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

   427

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

   428

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

   429

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

   430

						// Found a compatbiel industry

   431

						found = true;

   432

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

   433

	   					p->ainew.from_deliver = false;

   434

	   					p->ainew.to_deliver = true;

   435

	       				break;

   436

	       			}

   437

	   			}

   438

   			}

   439

   			if (found) {

   440

   				// Yeah, they are compatible!!!

   441

   				// Check the length against the amount of goods

   442

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

   443

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

   444

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

   445

	   				if (p->ainew.from_deliver) {

   446

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

   447

	   				} else {

   448

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

   449

   					}

   450

	   				p->ainew.state = AI_STATE_FIND_STATION;

   451

   452

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

   453

   454

	   				p->ainew.from_tile = 0;

   455

	   				p->ainew.to_tile = 0;

   456

   457

	   				return;

   458

	   			}

   459

   			}

   460

   		}

   461

   	}

   462

   463

    // It was not a valid city

   464

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

   465

   	//  to try again

   466

   	p->ainew.temp++;

   467

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

   468

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

   469

    } else {

   470

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

   471

    }

   472

   473

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

   474

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

   475

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

   476

}

   477

   478

// Check if there are not more then a certain amount of vehicles pointed to a certain

   479

//  station. This to prevent 10 busses going to one station, which gives... problems ;)

   480

static bool AiNew_CheckVehicleStation(Player *p, Station *st) {

   481

	int count = 0;

   482

	Vehicle *v;

   483

	uint16 *sched;

   484

	uint16 ord;

   485

   486

	// Also check if we don't have already a lot of busses to this city...

   487

	FOR_ALL_VEHICLES(v) {

   488

		if (v->owner == _current_player) {

   489

			sched = v->schedule_ptr;

   490

			while (sched != NULL && (ord=*sched++) != 0) {

   491

				if ((ord & OT_MASK) == OT_GOTO_STATION && DEREF_STATION(ord >> 8) == st) {

   492

					// This vehicle has this city in his list

   493

					count++;

   494

				}

   495

			}

   496

		}