1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "map.h"

     4

#include "tile.h"

     5

#include "player.h"

     6

#include "vehicle.h"

     7

#include "engine.h"

     8

#include "command.h"

     9

#include "town.h"

    10

#include "industry.h"

    11

#include "station.h"

    12

#include "pathfind.h"

    13

#include "economy.h"

    14

#include "airport.h"

    15

#include "depot.h"

    16

    17

// remove some day perhaps?

    18

static Player *_cur_ai_player;

    19

static uint _ai_service_interval;

    20

    21

typedef void AiStateAction(Player *p);

    22

    23

enum {

    24

	AIS_0 = 0,

    25

	AIS_1 = 1,

    26

	AIS_VEH_LOOP = 2,

    27

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    28

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    29

	AIS_WANT_NEW_ROUTE = 5,

    30

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    31

	AIS_BUILD_RAIL = 7,

    32

	AIS_BUILD_RAIL_VEH = 8,

    33

	AIS_DELETE_RAIL_BLOCKS = 9,

    34

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    35

	AIS_BUILD_ROAD = 11,

    36

	AIS_BUILD_ROAD_VEHICLES = 12,

    37

	AIS_DELETE_ROAD_BLOCKS = 13,

    38

	AIS_AIRPORT_STUFF = 14,

    39

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    40

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    41

	AIS_CHECK_SHIP_STUFF = 17,

    42

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    43

	AIS_DO_SHIP_STUFF = 19,

    44

	AIS_SELL_VEHICLE = 20,

    45

	AIS_REMOVE_STATION = 21,

    46

	AIS_REMOVE_TRACK = 22,

    47

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    48

};

    49

    50

    51

#include "table/ai_rail.h"

    52

    53

static byte GetRailTrackStatus(TileIndex tile) {

    54

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    55

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

    56

}

    57

    58

    59

static void AiCase0(Player *p)

    60

{

    61

	p->ai.state = AIS_REMOVE_TRACK;

    62

	p->ai.state_counter = 0;

    63

}

    64

    65

static void AiCase1(Player *p)

    66

{

    67

	p->ai.cur_veh = NULL;

    68

	p->ai.state = AIS_VEH_LOOP;

    69

}

    70

    71

static void AiStateVehLoop(Player *p)

    72

{

    73

	Vehicle *v;

    74

	uint index;

    75

    76

	index = (p->ai.cur_veh == NULL) ? 0 : p->ai.cur_veh->index + 1;

    77

    78

	FOR_ALL_VEHICLES_FROM(v, index) {

    79

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

    80

			continue;

    81

    82

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

    83

				v->type == VEH_Road ||

    84

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

    85

				v->type == VEH_Ship) {

    86

    87

			/* replace engine? */

    88

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

    89

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

    90

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

    91

				p->ai.cur_veh = v;

    92

				return;

    93

			}

    94

    95

			/* not profitable? */

    96

			if (v->age >= 730 &&

    97

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

    98

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

    99

				p->ai.state_counter = 0;

   100

				p->ai.state = AIS_SELL_VEHICLE;

   101

				p->ai.cur_veh = v;

   102

				return;

   103

			}

   104

   105

			/* not reliable? */

   106

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

   107

					GetEngine(v->engine_type)->reliability < 35389) ||

   108

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

   109

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   110

				p->ai.cur_veh = v;

   111

				return;

   112

			}

   113

		}

   114

	}

   115

   116

	p->ai.state = AIS_WANT_NEW_ROUTE;

   117

	p->ai.state_counter = 0;

   118

}

   119

   120

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

   121

{

   122

	int best_veh_index = -1;

   123

	byte best_veh_score = 0;

   124

	int32 ret;

   125

	int i;

   126

   127

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

   128

		const RailVehicleInfo *rvi = RailVehInfo(i);

   129

		const Engine* e = GetEngine(i);

   130

   131

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

   132

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

   133

			continue;

   134

   135

		ret = DoCommandByTile(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);

   136

		if (!CmdFailed(ret) && (!(_cmd_build_rail_veh_var1&1) || !(flag&1)) && ret <= money &&

   137

				_cmd_build_rail_veh_score >= best_veh_score) {

   138

			best_veh_score = _cmd_build_rail_veh_score;

   139

			best_veh_index = i;

   140

		}

   141

	}

   142

   143

	return best_veh_index;

   144

}

   145

   146

static int AiChooseRoadVehToBuild(byte cargo, int32 money, TileIndex tile)

   147

{

   148

	int best_veh_index = -1;

   149

	int32 best_veh_cost = 0;

   150

	int32 ret;

   151

   152

	int i = _cargoc.ai_roadveh_start[cargo];

   153

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

   154

	const Engine* e = GetEngine(i);

   155

   156

	do {

   157

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

   158

			continue;

   159

   160

		ret = DoCommandByTile(tile, i, 0, 0, CMD_BUILD_ROAD_VEH);

   161

		if (!CmdFailed(ret) && ret <= money && ret >= best_veh_cost) {

   162

			best_veh_cost = ret;

   163

			best_veh_index = i;

   164

		}

   165

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

   166

   167

	return best_veh_index;

   168

}

   169

   170

static int AiChooseAircraftToBuild(int32 money, byte flag)

   171

{

   172

	int best_veh_index = -1;

   173

	int32 best_veh_cost = 0;

   174

	int32 ret;

   175

   176

	int i = AIRCRAFT_ENGINES_INDEX;

   177

	int end = i + NUM_AIRCRAFT_ENGINES;

   178

	const Engine* e = GetEngine(i);

   179

   180

	do {

   181

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

   182

			continue;

   183

   184

		if (flag&1) {

   185

			if (i<253) continue;

   186

		} else {

   187

			if (i>=253) continue;

   188

		}

   189

   190

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

   191

		if (!CmdFailed(ret) && ret <= money && ret >= best_veh_cost) {

   192

			best_veh_cost = ret;

   193

			best_veh_index = i;

   194

		}

   195

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

   196

   197

	return best_veh_index;

   198

}

   199

   200

static int32 AiGetBasePrice(Player *p)

   201

{

   202

	int32 base = _price.station_value;

   203

   204

	// adjust base price when more expensive vehicles are available

   205

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

   206

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

   207

   208

	return base;

   209

}

   210

   211

#if 0

   212

static int AiChooseShipToBuild(byte cargo, int32 money)

   213

{

   214

	// XXX: not done

   215

	return 0;

   216

}

   217

#endif

   218

   219

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

   220

{

   221

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

   222

	return AiChooseRoadVehToBuild(v->cargo_type, avail_money, v->tile);

   223

}

   224

   225

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

   226

{

   227

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

   228

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

   229

}

   230

   231

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

   232

{

   233

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

   234

	int num=0;

   235

	Vehicle *u = v;

   236

   237

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

   238

		u = u->next;

   239

	}

   240

   241

	// XXX: check if a wagon

   242

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

   243

}

   244

   245

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

   246

{

   247

	error("!AiChooseShipToReplaceWith");

   248

   249

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

   250

	return 0;

   251

}

   252

   253

static void AiHandleGotoDepot(Player *p, int cmd)

   254

{

   255

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

   256

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

   257

   258

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

   259

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   260

		return;

   261

	}

   262

   263

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

   264

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

   265

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

   266

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

   267

	}

   268

}

   269

   270

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

   271

{

   272

	int i;

   273

   274

	for (i = 0; bak->order[i].type != OT_NOTHING; i++)

   275

		if (CmdFailed(DoCommandP(0, v->index + (i << 16), PackOrder(&bak->order[i]), NULL, CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK)))

   276

			break;

   277

}

   278

   279

static void AiHandleReplaceTrain(Player *p)

   280

{

   281

	Vehicle *v = p->ai.cur_veh;

   282

	BackuppedOrders orderbak[1];

   283

	int veh;

   284

   285

	// wait until the vehicle reaches the depot.

   286

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

   287

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   288

		return;

   289

	}

   290

   291

	veh = AiChooseTrainToReplaceWith(p, v);

   292

	if (veh != -1) {

   293

		TileIndex tile;

   294

   295

		BackupVehicleOrders(v, orderbak);

   296

		tile = v->tile;

   297

   298

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

   299

			  !CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE)) ) {

   300

			veh = _new_train_id;

   301

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   302

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

   303

   304

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

   305

		}

   306

	}

   307

}

   308

   309

static void AiHandleReplaceRoadVeh(Player *p)

   310

{

   311

	Vehicle *v = p->ai.cur_veh;

   312

	BackuppedOrders orderbak[1];

   313

	int veh;

   314

   315

	if (!IsTileDepotType(v->tile, TRANSPORT_ROAD) || 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

		TileIndex tile;

   323

   324

		BackupVehicleOrders(v, orderbak);

   325

		tile = v->tile;

   326

   327

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

   328

			  !CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH)) ) {

   329

			veh = _new_roadveh_id;

   330

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   331

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

   332

   333

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

   334

		}

   335

	}

   336

}

   337

   338

static void AiHandleReplaceAircraft(Player *p)

   339

{

   340

	Vehicle *v = p->ai.cur_veh;

   341

	int veh;

   342

	BackuppedOrders orderbak[1];

   343

   344

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

   345

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   346

		return;

   347

	}

   348

   349

	veh = AiChooseAircraftToReplaceWith(p, v);

   350

	if (veh != -1) {

   351

		TileIndex tile;

   352

   353

		BackupVehicleOrders(v, orderbak);

   354

		tile = v->tile;

   355

   356

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

   357

			  !CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT)) ) {

   358

			veh = _new_aircraft_id;

   359

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   360

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

   361

   362

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

   363

		}

   364

	}

   365

}

   366

   367

static void AiHandleReplaceShip(Player *p)

   368

{

   369

	error("!AiHandleReplaceShip");

   370

}

   371

   372

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

   373

   374

static CheckReplaceProc * const _veh_check_replace_proc[] = {

   375

	AiChooseTrainToReplaceWith,

   376

	AiChooseRoadVehToReplaceWith,

   377

	AiChooseShipToReplaceWith,

   378

	AiChooseAircraftToReplaceWith,

   379

};

   380

   381

typedef void DoReplaceProc(Player *p);

   382

static DoReplaceProc * const _veh_do_replace_proc[] = {

   383

	AiHandleReplaceTrain,

   384

	AiHandleReplaceRoadVeh,

   385

	AiHandleReplaceShip,

   386

	AiHandleReplaceAircraft

   387

};

   388

   389

static void AiStateCheckReplaceVehicle(Player *p)

   390

{

   391

	Vehicle *v = p->ai.cur_veh;

   392

   393

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

   394

		p->ai.state = AIS_VEH_LOOP;

   395

	} else {

   396

		p->ai.state_counter = 0;

   397

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   398

	}

   399

}

   400

   401

static void AiStateDoReplaceVehicle(Player *p)

   402

{

   403

	Vehicle *v = p->ai.cur_veh;

   404

	p->ai.state = AIS_VEH_LOOP;

   405

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

   406

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

   407

		return;

   408

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

   409

}

   410

   411

typedef struct FoundRoute {

   412

	int distance;

   413

	byte cargo;

   414

	void *from;

   415

	void *to;

   416

} FoundRoute;

   417

   418

static Town *AiFindRandomTown(void)

   419

{

   420

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

   421

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

   422

}

   423

   424

static Industry *AiFindRandomIndustry(void)

   425

{

   426

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

   427

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

   428

}

   429

   430

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   431

{

   432

	uint i;

   433

	byte cargo;

   434

	Subsidy *s;

   435

	Industry *from, *to_ind;

   436

	Town *to_tow;

   437

	TileIndex to_xy;

   438

   439

	// initially error

   440

	fr->distance = -1;

   441

   442

	// Randomize subsidy index..

   443

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

   444

	if (i >= lengthof(_subsidies))

   445

		return;

   446

   447

	s = &_subsidies[i];

   448

   449

	// Don't want passengers or mail

   450

	cargo = s->cargo_type;

   451

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

   452

		return;

   453

	fr->cargo = cargo;

   454

   455

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

   456

   457

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

   458

		to_tow = GetTown(s->to);

   459

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

   460

			return; // error

   461

		fr->to = to_tow;

   462

		to_xy = to_tow->xy;

   463

	} else {

   464

		to_ind = GetIndustry(s->to);

   465

		fr->to = to_ind;

   466

		to_xy = to_ind->xy;

   467

	}

   468

   469

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

   470

}

   471

   472

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   473

{

   474

	uint i;

   475

	Subsidy *s;

   476

	Town *from,*to;

   477

   478

	// initially error

   479

	fr->distance = -1;

   480

   481

	// Randomize subsidy index..

   482

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

   483

	if (i >= lengthof(_subsidies))

   484

		return;

   485

   486

	s = &_subsidies[i];

   487

   488

	// Only want passengers

   489

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

   490

		return;

   491

	fr->cargo = s->cargo_type;

   492

   493

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

   494

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

   495

   496

	// They must be big enough

   497

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

   498

		return;

   499

   500

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

   501

}

   502

   503

static void AiFindRandomIndustryRoute(FoundRoute *fr)

   504

{

   505

	Industry *i,*i2;

   506

	Town *t;

   507

	uint32 r;

   508

	byte cargo;

   509

   510

	// initially error

   511

	fr->distance = -1;

   512

   513

	r = Random();

   514

   515

	// pick a source

   516

	fr->from = i = AiFindRandomIndustry();