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

#include "variables.h"

    17

    18

// remove some day perhaps?

    19

static Player *_cur_ai_player;

    20

static uint _ai_service_interval;

    21

    22

typedef void AiStateAction(Player *p);

    23

    24

enum {

    25

	AIS_0 = 0,

    26

	AIS_1 = 1,

    27

	AIS_VEH_LOOP = 2,

    28

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    29

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    30

	AIS_WANT_NEW_ROUTE = 5,

    31

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    32

	AIS_BUILD_RAIL = 7,

    33

	AIS_BUILD_RAIL_VEH = 8,

    34

	AIS_DELETE_RAIL_BLOCKS = 9,

    35

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    36

	AIS_BUILD_ROAD = 11,

    37

	AIS_BUILD_ROAD_VEHICLES = 12,

    38

	AIS_DELETE_ROAD_BLOCKS = 13,

    39

	AIS_AIRPORT_STUFF = 14,

    40

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    41

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    42

	AIS_CHECK_SHIP_STUFF = 17,

    43

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    44

	AIS_DO_SHIP_STUFF = 19,

    45

	AIS_SELL_VEHICLE = 20,

    46

	AIS_REMOVE_STATION = 21,

    47

	AIS_REMOVE_TRACK = 22,

    48

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    49

};

    50

    51

    52

#include "table/ai_rail.h"

    53

    54

static byte GetRailTrackStatus(TileIndex tile) {

    55

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    56

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

    57

}

    58

    59

    60

static void AiCase0(Player *p)

    61

{

    62

	p->ai.state = AIS_REMOVE_TRACK;

    63

	p->ai.state_counter = 0;

    64

}

    65

    66

static void AiCase1(Player *p)

    67

{

    68

	p->ai.cur_veh = NULL;

    69

	p->ai.state = AIS_VEH_LOOP;

    70

}

    71

    72

static void AiStateVehLoop(Player *p)

    73

{

    74

	Vehicle *v;

    75

	uint index;

    76

    77

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

    78

    79

	FOR_ALL_VEHICLES_FROM(v, index) {

    80

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

    81

			continue;

    82

    83

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

    84

				v->type == VEH_Road ||

    85

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

    86

				v->type == VEH_Ship) {

    87

    88

			/* replace engine? */

    89

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

    90

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

    91

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

    92

				p->ai.cur_veh = v;

    93

				return;

    94

			}

    95

    96

			/* not profitable? */

    97

			if (v->age >= 730 &&

    98

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

    99

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

   100

				p->ai.state_counter = 0;

   101

				p->ai.state = AIS_SELL_VEHICLE;

   102

				p->ai.cur_veh = v;

   103

				return;

   104

			}

   105

   106

			/* not reliable? */

   107

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

   108

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

   109

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

   110

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   111

				p->ai.cur_veh = v;

   112

				return;

   113

			}

   114

		}

   115

	}

   116

   117

	p->ai.state = AIS_WANT_NEW_ROUTE;

   118

	p->ai.state_counter = 0;

   119

}

   120

   121

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

   122

{

   123

	int best_veh_index = -1;

   124

	byte best_veh_score = 0;

   125

	int32 ret;

   126

	int i;

   127

   128

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

   129

		const RailVehicleInfo *rvi = RailVehInfo(i);

   130

		const Engine* e = GetEngine(i);

   131

   132

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

   133

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

   134

			continue;

   135

   136

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

   137

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

   138

				_cmd_build_rail_veh_score >= best_veh_score) {

   139

			best_veh_score = _cmd_build_rail_veh_score;

   140

			best_veh_index = i;

   141

		}

   142

	}

   143

   144

	return best_veh_index;

   145

}

   146

   147

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

   148

{

   149

	int best_veh_index = -1;

   150

	int32 best_veh_cost = 0;

   151

	int32 ret;

   152

   153

	int i = _cargoc.ai_roadveh_start[cargo];

   154

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

   155

	const Engine* e = GetEngine(i);

   156

   157

	do {

   158

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

   159

			continue;

   160

   161

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

   162

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

   163

			best_veh_cost = ret;

   164

			best_veh_index = i;

   165

		}

   166

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

   167

   168

	return best_veh_index;

   169

}

   170

   171

static int AiChooseAircraftToBuild(int32 money, byte flag)

   172

{

   173

	int best_veh_index = -1;

   174

	int32 best_veh_cost = 0;

   175

	int32 ret;

   176

   177

	int i = AIRCRAFT_ENGINES_INDEX;

   178

	int end = i + NUM_AIRCRAFT_ENGINES;

   179

	const Engine* e = GetEngine(i);

   180

   181

	do {

   182

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

   183

			continue;

   184

   185

		if (flag&1) {

   186

			if (i<253) continue;

   187

		} else {

   188

			if (i>=253) continue;

   189

		}

   190

   191

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

   192

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

   193

			best_veh_cost = ret;

   194

			best_veh_index = i;

   195

		}

   196

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

   197

   198

	return best_veh_index;

   199

}

   200

   201

static int32 AiGetBasePrice(Player *p)

   202

{

   203

	int32 base = _price.station_value;

   204

   205

	// adjust base price when more expensive vehicles are available

   206

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

   207

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

   208

   209

	return base;

   210

}

   211

   212

#if 0

   213

static int AiChooseShipToBuild(byte cargo, int32 money)

   214

{

   215

	// XXX: not done

   216

	return 0;

   217

}

   218

#endif

   219

   220

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

   221

{

   222

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

   223

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

   224

}

   225

   226

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

   227

{

   228

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

   229

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

   230

}

   231

   232

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

   233

{

   234

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

   235

	int num=0;

   236

	Vehicle *u = v;

   237

   238

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

   239

		u = u->next;

   240

	}

   241

   242

	// XXX: check if a wagon

   243

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

   244

}

   245

   246

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

   247

{

   248

	error("!AiChooseShipToReplaceWith");

   249

   250

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

   251

	return 0;

   252

}

   253

   254

static void AiHandleGotoDepot(Player *p, int cmd)

   255

{

   256

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

   257

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

   258

   259

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

   260

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   261

		return;

   262

	}

   263

   264

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

   265

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

   266

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

   267

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

   268

	}

   269

}

   270

   271

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

   272

{

   273

	int i;

   274

   275

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

   276

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

   277

			break;

   278

}

   279

   280

static void AiHandleReplaceTrain(Player *p)

   281

{

   282

	Vehicle *v = p->ai.cur_veh;

   283

	BackuppedOrders orderbak[1];

   284

	int veh;

   285

   286

	// wait until the vehicle reaches the depot.

   287

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

		TileIndex tile;

   295

   296

		BackupVehicleOrders(v, orderbak);

   297

		tile = v->tile;

   298

   299

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

   300

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

   301

			veh = _new_train_id;

   302

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   303

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

   304

   305

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

   306

		}

   307

	}

   308

}

   309

   310

static void AiHandleReplaceRoadVeh(Player *p)

   311

{

   312

	Vehicle *v = p->ai.cur_veh;

   313

	BackuppedOrders orderbak[1];

   314

	int veh;

   315

   316

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

   317

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   318

		return;

   319

	}

   320

   321

	veh = AiChooseRoadVehToReplaceWith(p, v);

   322

	if (veh != -1) {

   323

		TileIndex tile;

   324

   325

		BackupVehicleOrders(v, orderbak);

   326

		tile = v->tile;

   327

   328

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

   329

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

   330

			veh = _new_roadveh_id;

   331

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   332

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

   333

   334

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

   335

		}

   336

	}

   337

}

   338

   339

static void AiHandleReplaceAircraft(Player *p)

   340

{

   341

	Vehicle *v = p->ai.cur_veh;

   342

	int veh;

   343

	BackuppedOrders orderbak[1];

   344

   345

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

   346

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   347

		return;

   348

	}

   349

   350

	veh = AiChooseAircraftToReplaceWith(p, v);

   351

	if (veh != -1) {

   352

		TileIndex tile;

   353

   354

		BackupVehicleOrders(v, orderbak);

   355

		tile = v->tile;

   356

   357

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

   358

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

   359

			veh = _new_aircraft_id;

   360

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   361

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

   362

   363

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

   364

		}

   365

	}

   366

}

   367

   368

static void AiHandleReplaceShip(Player *p)

   369

{

   370

	error("!AiHandleReplaceShip");

   371

}

   372

   373

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

   374

   375

static CheckReplaceProc * const _veh_check_replace_proc[] = {

   376

	AiChooseTrainToReplaceWith,

   377

	AiChooseRoadVehToReplaceWith,

   378

	AiChooseShipToReplaceWith,

   379

	AiChooseAircraftToReplaceWith,

   380

};

   381

   382

typedef void DoReplaceProc(Player *p);

   383

static DoReplaceProc * const _veh_do_replace_proc[] = {

   384

	AiHandleReplaceTrain,

   385

	AiHandleReplaceRoadVeh,

   386

	AiHandleReplaceShip,

   387

	AiHandleReplaceAircraft

   388

};

   389

   390

static void AiStateCheckReplaceVehicle(Player *p)

   391

{

   392

	Vehicle *v = p->ai.cur_veh;

   393

   394

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

   395

		p->ai.state = AIS_VEH_LOOP;

   396

	} else {

   397

		p->ai.state_counter = 0;

   398

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   399

	}

   400

}

   401

   402

static void AiStateDoReplaceVehicle(Player *p)

   403

{

   404

	Vehicle *v = p->ai.cur_veh;

   405

	p->ai.state = AIS_VEH_LOOP;

   406

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

   407

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

   408

		return;

   409

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

   410

}

   411

   412

typedef struct FoundRoute {

   413

	int distance;

   414

	byte cargo;

   415

	void *from;

   416

	void *to;

   417

} FoundRoute;

   418

   419

static Town *AiFindRandomTown(void)

   420

{

   421

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

   422

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

   423

}

   424

   425

static Industry *AiFindRandomIndustry(void)

   426

{

   427

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

   428

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

   429

}

   430

   431

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   432

{

   433

	uint i;

   434

	byte cargo;

   435

	Subsidy *s;

   436

	Industry *from, *to_ind;

   437

	Town *to_tow;

   438

	TileIndex to_xy;

   439

   440

	// initially error

   441

	fr->distance = -1;

   442

   443

	// Randomize subsidy index..

   444

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

   445

	if (i >= lengthof(_subsidies))

   446

		return;

   447

   448

	s = &_subsidies[i];

   449

   450

	// Don't want passengers or mail

   451

	cargo = s->cargo_type;

   452

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

   453

		return;

   454

	fr->cargo = cargo;

   455

   456

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

   457

   458

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

   459

		to_tow = GetTown(s->to);

   460

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

   461

			return; // error

   462

		fr->to = to_tow;

   463

		to_xy = to_tow->xy;

   464

	} else {

   465

		to_ind = GetIndustry(s->to);

   466

		fr->to = to_ind;

   467

		to_xy = to_ind->xy;

   468

	}

   469

   470

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

   471

}

   472

   473

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   474

{

   475

	uint i;

   476

	Subsidy *s;

   477

	Town *from,*to;

   478

   479

	// initially error

   480

	fr->distance = -1;

   481

   482

	// Randomize subsidy index..

   483

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

   484

	if (i >= lengthof(_subsidies))

   485

		return;

   486

   487

	s = &_subsidies[i];

   488

   489

	// Only want passengers

   490

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

   491

		return;

   492

	fr->cargo = s->cargo_type;

   493

   494

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

   495

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

   496

   497

	// They must be big enough

   498

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

   499

		return;

   500

   501

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

   502

}

   503

   504

static void AiFindRandomIndustryRoute(FoundRoute *fr)

   505

{

   506

	Industry *i,*i2;

   507

	Town *t;

   508

	uint32 r;

   509

	byte cargo;

   510

   511

	// initially error

   512

	fr->distance = -1;

   513

   514

	r = Random();

   515

   516

	// pick a source