1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "player.h"

     5

#include "vehicle.h"

     6

#include "engine.h"

     7

#include "command.h"

     8

#include "town.h"

     9

#include "industry.h"

    10

#include "station.h"

    11

#include "pathfind.h"

    12

#include "economy.h"

    13

#include "airport.h"

    14

    15

// remove some day perhaps?

    16

static Player *_cur_ai_player;

    17

static uint _ai_service_interval;

    18

    19

typedef void AiStateAction(Player *p);

    20

    21

enum {

    22

	AIS_0 = 0,

    23

	AIS_1 = 1,

    24

	AIS_VEH_LOOP = 2,

    25

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    26

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    27

	AIS_WANT_NEW_ROUTE = 5,

    28

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    29

	AIS_BUILD_RAIL = 7,

    30

	AIS_BUILD_RAIL_VEH = 8,

    31

	AIS_DELETE_RAIL_BLOCKS = 9,

    32

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    33

	AIS_BUILD_ROAD = 11,

    34

	AIS_BUILD_ROAD_VEHICLES = 12,

    35

	AIS_DELETE_ROAD_BLOCKS = 13,

    36

	AIS_AIRPORT_STUFF = 14,

    37

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    38

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    39

	AIS_CHECK_SHIP_STUFF = 17,

    40

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    41

	AIS_DO_SHIP_STUFF = 19,

    42

	AIS_SELL_VEHICLE = 20,

    43

	AIS_REMOVE_STATION = 21,

    44

	AIS_REMOVE_TRACK = 22,

    45

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    46

};

    47

    48

    49

#include "table/ai_rail.h"

    50

    51

static byte GetRailTrackStatus(TileIndex tile) {

    52

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    53

	return (byte) (r | r >> 8);

    54

}

    55

    56

    57

static void AiCase0(Player *p)

    58

{

    59

	p->ai.state = AIS_REMOVE_TRACK;

    60

	p->ai.state_counter = 0;

    61

}

    62

    63

static void AiCase1(Player *p)

    64

{

    65

	p->ai.cur_veh = NULL;

    66

	p->ai.state = AIS_VEH_LOOP;

    67

}

    68

    69

static void AiStateVehLoop(Player *p)

    70

{

    71

	Vehicle *v;

    72

    73

	v = p->ai.cur_veh == NULL ? _vehicles : p->ai.cur_veh+1;

    74

    75

	for (;v != endof(_vehicles); v++) {

    76

		if (v->type == 0 || v->owner != _current_player)

    77

			continue;

    78

    79

		if ((v->type == VEH_Train && v->subtype==0) ||

    80

				v->type == VEH_Road ||

    81

				(v->type == VEH_Aircraft && v->subtype <= 2) ||

    82

				v->type == VEH_Ship) {

    83

    84

			/* replace engine? */

    85

			if (v->type == VEH_Train && v->engine_type < 3 &&

    86

					(_price.build_railvehicle >> 3) < p->player_money) {

    87

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

    88

				p->ai.cur_veh = v;

    89

				return;

    90

			}

    91

    92

			/* not profitable? */

    93

			if (v->age >= 730 &&

    94

					v->profit_last_year < _price.station_value*5 &&

    95

					v->profit_this_year < _price.station_value*5) {

    96

				p->ai.state_counter = 0;

    97

				p->ai.state = AIS_SELL_VEHICLE;

    98

				p->ai.cur_veh = v;

    99

				return;

   100

			}

   101

   102

			/* not reliable? */

   103

			if ((v->age != 0 &&

   104

					_engines[v->engine_type].reliability < 35389) ||

   105

					v->age >= v->max_age) {

   106

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   107

				p->ai.cur_veh = v;

   108

				return;

   109

			}

   110

		}

   111

	}

   112

   113

	p->ai.state = AIS_WANT_NEW_ROUTE;

   114

	p->ai.state_counter = 0;

   115

}

   116

   117

static int AiChooseTrainToBuild(byte railtype, int32 money, byte flag)

   118

{

   119

	int best_veh_index = -1;

   120

	byte best_veh_score = 0;

   121

	int32 r;

   122

	int i;

   123

   124

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

   125

		const RailVehicleInfo *rvi = RailVehInfo(i);

   126

		Engine *e = DEREF_ENGINE(i);

   127

   128

		if (e->railtype != railtype || rvi->flags & RVI_WAGON

   129

		    || !HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D)

   130

			continue;

   131

   132

		r = DoCommandByTile(0, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);

   133

		if (r != CMD_ERROR &&

   134

					(!(_cmd_build_rail_veh_var1&1) || !(flag&1)) &&

   135

					r <= money &&

   136

				_cmd_build_rail_veh_score >= best_veh_score) {

   137

			best_veh_score = _cmd_build_rail_veh_score;

   138

			best_veh_index = i;

   139

		}

   140

	}

   141

   142

	return best_veh_index;

   143

}

   144

   145

static int AiChooseRoadVehToBuild(byte cargo, int32 money)

   146

{

   147

	int best_veh_index = -1;

   148

	int32 best_veh_cost = 0;

   149

	int32 r;

   150

   151

	int i = _cargoc.ai_roadveh_start[cargo];

   152

	int end = i + _cargoc.ai_roadveh_count[cargo];

   153

	Engine *e = &_engines[i];

   154

	do {

   155

		if (!HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D)

   156

			continue;

   157

   158

		r = DoCommandByTile(0, i, 0, 0, CMD_BUILD_ROAD_VEH);

   159

		if (r != CMD_ERROR && r <= money && r >= best_veh_cost) {

   160

			best_veh_cost = r;

   161

			best_veh_index = i;

   162

		}

   163

	} while (++e, ++i != end);

   164

   165

	return best_veh_index;

   166

}

   167

   168

static int AiChooseAircraftToBuild(int32 money, byte flag)

   169

{

   170

	int best_veh_index = -1;

   171

	int32 best_veh_cost = 0;

   172

	int32 r;

   173

   174

	int i = AIRCRAFT_ENGINES_INDEX;

   175

	int end = i + NUM_AIRCRAFT_ENGINES;

   176

	Engine *e = &_engines[i];

   177

	do {

   178

		if (!HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D)

   179

			continue;

   180

   181

		if (flag&1) {

   182

			if (i<253) continue;

   183

		} else {

   184

			if (i>=253) continue;

   185

		}

   186

   187

		r = DoCommandByTile(0, i, 0, 0, CMD_BUILD_AIRCRAFT);

   188

		if (r != CMD_ERROR && r <= money && r >= best_veh_cost) {

   189

			best_veh_cost = r;

   190

			best_veh_index = i;

   191

		}

   192

	} while (++e, ++i != end);

   193

   194

	return best_veh_index;

   195

}

   196

   197

static int32 AiGetBasePrice(Player *p)

   198

{

   199

	int32 base = _price.station_value;

   200

   201

	// adjust base price when more expensive vehicles are available

   202

	if (p->ai.railtype_to_use == 1) base = (base * 3) >> 1;

   203

	else if (p->ai.railtype_to_use == 2) base *= 2;

   204

   205

	return base;

   206

}

   207

   208

#if 0

   209

static int AiChooseShipToBuild(byte cargo, int32 money)

   210

{

   211

	// XXX: not done

   212

	return 0;

   213

}

   214

#endif

   215

   216

static int AiChooseRoadVehToReplaceWith(Player *p, Vehicle *v)

   217

{

   218

	int32 avail_money = p->player_money + v->value;

   219

	return AiChooseRoadVehToBuild(v->cargo_type, avail_money);

   220

}

   221

   222

static int AiChooseAircraftToReplaceWith(Player *p, Vehicle *v)

   223

{

   224

	int32 avail_money = p->player_money + v->value;

   225

	return AiChooseAircraftToBuild(avail_money, v->engine_type>=253?1:0);

   226

}

   227

   228

static int AiChooseTrainToReplaceWith(Player *p, Vehicle *v)

   229

{

   230

	int32 avail_money = p->player_money + v->value;

   231

	int num=0;

   232

	Vehicle *u = v;

   233

   234

	while (++num, u->next != NULL) {

   235

		u = u->next;

   236

	}

   237

   238

	// XXX: check if a wagon

   239

	return AiChooseTrainToBuild(v->u.rail.railtype, avail_money, 0);

   240

}

   241

   242

static int AiChooseShipToReplaceWith(Player *p, Vehicle *v)

   243

{

   244

	error("!AiChooseShipToReplaceWith");

   245

   246

	/* maybe useless, but avoids compiler warning this way */

   247

	return 0;

   248

}

   249

   250

static void AiHandleGotoDepot(Player *p, int cmd)

   251

{

   252

	if (p->ai.cur_veh->current_order.type != OT_GOTO_DEPOT)

   253

		DoCommandByTile(0, p->ai.cur_veh->index, 0, DC_EXEC, cmd);

   254

   255

	if (++p->ai.state_counter <= 1387) {

   256

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   257

		return;

   258

	}

   259

   260

	if (p->ai.cur_veh->current_order.type == OT_GOTO_DEPOT) {

   261

		p->ai.cur_veh->current_order.type = OT_DUMMY;

   262

		p->ai.cur_veh->current_order.flags = 0;

   263

		InvalidateWindow(WC_VEHICLE_VIEW, p->ai.cur_veh->index);

   264

	}

   265

}

   266

   267

static void AiRestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak)

   268

{

   269

	const Order *os = bak->order;

   270

	int ind = 0;

   271

   272

	while (os++->type != OT_NOTHING) {

   273

		if (DoCommandByTile(0, v->index + (ind << 16), PackOrder(os), DC_EXEC, CMD_INSERT_ORDER) == CMD_ERROR)

   274

			break;

   275

		ind++;

   276

	}

   277

}

   278

   279

static void AiHandleReplaceTrain(Player *p)

   280

{

   281

	Vehicle *v = p->ai.cur_veh;

   282

	BackuppedOrders orderbak[1];

   283

	int veh;

   284

	uint tile;

   285

   286

	// wait until the vehicle reaches the depot.

   287

	if (!IsTrainDepotTile(v->tile) || v->u.rail.track != 0x80 || !(v->vehstatus&VS_STOPPED)) {

   288

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   289

		return;

   290

	}

   291

   292

	veh = AiChooseTrainToReplaceWith(p, v);

   293

	if (veh != -1) {

   294

		BackupVehicleOrders(v, orderbak);

   295

		tile = v->tile;

   296

   297

		if (DoCommandByTile(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON) != CMD_ERROR &&

   298

			 DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE) != CMD_ERROR) {

   299

			veh = _new_train_id;

   300

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   301

			DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_TRAIN);

   302

   303

			DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_TRAIN_SERVICE_INT);

   304

		}

   305

	}

   306

}

   307

   308

static void AiHandleReplaceRoadVeh(Player *p)

   309

{

   310

	Vehicle *v = p->ai.cur_veh;

   311

	BackuppedOrders orderbak[1];

   312

	int veh;

   313

	uint tile;

   314

   315

	if (!IsRoadDepotTile(v->tile) || v->u.road.state != 254 || !(v->vehstatus&VS_STOPPED)) {

   316

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   317

		return;

   318

	}

   319

   320

	veh = AiChooseRoadVehToReplaceWith(p, v);

   321

	if (veh != -1) {

   322

		BackupVehicleOrders(v, orderbak);

   323

		tile = v->tile;

   324

   325

		if (DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH) != CMD_ERROR &&

   326

			 DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH) != CMD_ERROR) {

   327

			veh = _new_roadveh_id;

   328

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   329

			DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_ROADVEH);

   330

   331

			DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_TRAIN_SERVICE_INT);

   332

		}

   333

	}

   334

}

   335

   336

static void AiHandleReplaceAircraft(Player *p)

   337

{

   338

	Vehicle *v = p->ai.cur_veh;

   339

	int veh;

   340

	BackuppedOrders orderbak[1];

   341

	uint tile;

   342

   343

	if (!IsAircraftHangarTile(v->tile) && !(v->vehstatus&VS_STOPPED)) {

   344

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   345

		return;

   346

	}

   347

   348

	veh = AiChooseAircraftToReplaceWith(p, v);

   349

	if (veh != -1) {

   350

		BackupVehicleOrders(v, orderbak);

   351

		tile = v->tile;

   352

   353

		if (DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT) != CMD_ERROR &&

   354

			 DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT) != CMD_ERROR) {

   355

			veh = _new_aircraft_id;

   356

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   357

			DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_AIRCRAFT);

   358

   359

			DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_TRAIN_SERVICE_INT);

   360

		}

   361

	}

   362

}

   363

   364

static void AiHandleReplaceShip(Player *p)

   365

{

   366

	error("!AiHandleReplaceShip");

   367

}

   368

   369

typedef int CheckReplaceProc(Player *p, Vehicle *v);

   370

   371

static CheckReplaceProc * const _veh_check_replace_proc[] = {

   372

	AiChooseTrainToReplaceWith,

   373

	AiChooseRoadVehToReplaceWith,

   374

	AiChooseShipToReplaceWith,

   375

	AiChooseAircraftToReplaceWith,

   376

};

   377

   378

typedef void DoReplaceProc(Player *p);

   379

static DoReplaceProc * const _veh_do_replace_proc[] = {

   380

	AiHandleReplaceTrain,

   381

	AiHandleReplaceRoadVeh,

   382

	AiHandleReplaceShip,

   383

	AiHandleReplaceAircraft

   384

};

   385

   386

static void AiStateCheckReplaceVehicle(Player *p)

   387

{

   388

	Vehicle *v = p->ai.cur_veh;

   389

   390

	if (v->type == 0 || v->owner != _current_player || v->type > VEH_Ship || _veh_check_replace_proc[v->type - VEH_Train](p, v) == -1) {

   391

		p->ai.state = AIS_VEH_LOOP;

   392

	} else {

   393

		p->ai.state_counter = 0;

   394

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   395

	}

   396

}

   397

   398

static void AiStateDoReplaceVehicle(Player *p)

   399

{

   400

	Vehicle *v = p->ai.cur_veh;

   401

	p->ai.state = AIS_VEH_LOOP;

   402

	// vehicle is not owned by the player anymore, something went very wrong.

   403

	if (v->type == 0 || v->owner != _current_player)

   404

		return;

   405

	_veh_do_replace_proc[v->type - VEH_Train](p);

   406

}

   407

   408

typedef struct FoundRoute {

   409

	int distance;

   410

	byte cargo;

   411

	void *from;

   412

	void *to;

   413

} FoundRoute;

   414

   415

static Town *AiFindRandomTown() {

   416

	Town *t = DEREF_TOWN(RandomRange(_total_towns));

   417

	return (t->xy != 0) ? t : NULL;

   418

}

   419

   420

static Industry *AiFindRandomIndustry() {

   421

	Industry *i = DEREF_INDUSTRY(RandomRange(_total_industries));

   422

	return (i->xy != 0) ? i : NULL;

   423

}

   424

   425

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   426

{

   427

	int i;

   428

	byte cargo;

   429

	Subsidy *s;

   430

	Industry *from, *to_ind;

   431

	Town *to_tow;

   432

	TileIndex to_xy;

   433

   434

	// initially error

   435

	fr->distance = -1;

   436

   437

	// Randomize subsidy index..

   438

	i = RandomRange(lengthof(_subsidies) * 3);

   439

	if (i >= lengthof(_subsidies))

   440

		return;

   441

   442

	s = &_subsidies[i];

   443

   444

	// Don't want passengers or mail

   445

	cargo = s->cargo_type;

   446

	if (cargo == 0xFF || cargo == CT_PASSENGERS || cargo == CT_MAIL || s->age > 7)

   447

		return;

   448

	fr->cargo = cargo;

   449

   450

	fr->from = from = DEREF_INDUSTRY(s->from);

   451

   452

	if (cargo == CT_GOODS || cargo == CT_FOOD) {

   453

		to_tow = DEREF_TOWN(s->to);

   454

		if (to_tow->population < (uint32)(cargo == CT_FOOD ? 200 : 900))

   455

			return; // error

   456

		fr->to = to_tow;

   457

		to_xy = to_tow->xy;

   458

	} else {

   459

		to_ind = DEREF_INDUSTRY(s->to);

   460

		fr->to = to_ind;

   461

		to_xy = to_ind->xy;

   462

	}

   463

   464

	fr->distance = GetTileDist(from->xy, to_xy);

   465

}

   466

   467

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   468

{

   469

	uint i;

   470

	Subsidy *s;

   471

	Town *from,*to;

   472

   473

	// initially error

   474

	fr->distance = -1;

   475

   476

	// Randomize subsidy index..

   477

	i = RandomRange(lengthof(_subsidies) * 3);

   478

	if (i >= lengthof(_subsidies))

   479

		return;

   480

   481

	s = &_subsidies[i];

   482

   483

	// Only want passengers

   484

	if (s->cargo_type != CT_PASSENGERS || s->age > 7)

   485

		return;

   486

	fr->cargo = s->cargo_type;

   487

   488

	fr->from = from = DEREF_TOWN(s->from);

   489

	fr->to = to = DEREF_TOWN(s->to);

   490

   491

	// They must be big enough

   492

	if (from->population < 400 || to->population < 400)

   493

		return;

   494

   495

	fr->distance = GetTileDist(from->xy, to->xy);

   496

}

   497

   498

static void AiFindRandomIndustryRoute(FoundRoute *fr)

   499

{

   500

	Industry *i,*i2;

   501

	Town *t;

   502

	uint32 r;

   503

	byte cargo;

   504

   505

	// initially error

   506

	fr->distance = -1;

   507

   508

	r = Random();

   509

   510

	// pick a source

   511

	fr->from = i = AiFindRandomIndustry();

   512

	if (i == NULL)

   513

		return;

   514

   515

	// pick a random produced cargo

   516

	cargo = i->produced_cargo[0];

   517

	if (r&1 && i->produced_cargo[1] != 0xFF)

   518

		cargo = i->produced_cargo[1];

   519

   520

	fr->cargo = cargo;

   521

   522

	// don't allow passengers

   523

	if (cargo == 0xFF || cargo == CT_PASSENGERS)

   524

		return;