1

/* $Id$ */

     2

     3

#include "../../stdafx.h"

     4

#include "../../openttd.h"

     5

#include "../../functions.h"

     6

#include "../../map.h"

     7

#include "../../tile.h"

     8

#include "../../player.h"

     9

#include "../../vehicle.h"

    10

#include "../../engine.h"

    11

#include "../../command.h"

    12

#include "../../town.h"

    13

#include "../../industry.h"

    14

#include "../../station.h"

    15

#include "../../pathfind.h"

    16

#include "../../economy.h"

    17

#include "../../airport.h"

    18

#include "../../depot.h"

    19

#include "../../variables.h"

    20

#include "default.h"

    21

    22

// remove some day perhaps?

    23

static Player *_cur_ai_player;

    24

static uint _ai_service_interval;

    25

    26

typedef void AiStateAction(Player *p);

    27

    28

enum {

    29

	AIS_0 = 0,

    30

	AIS_1 = 1,

    31

	AIS_VEH_LOOP = 2,

    32

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    33

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    34

	AIS_WANT_NEW_ROUTE = 5,

    35

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    36

	AIS_BUILD_RAIL = 7,

    37

	AIS_BUILD_RAIL_VEH = 8,

    38

	AIS_DELETE_RAIL_BLOCKS = 9,

    39

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    40

	AIS_BUILD_ROAD = 11,

    41

	AIS_BUILD_ROAD_VEHICLES = 12,

    42

	AIS_DELETE_ROAD_BLOCKS = 13,

    43

	AIS_AIRPORT_STUFF = 14,

    44

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    45

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    46

	AIS_CHECK_SHIP_STUFF = 17,

    47

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    48

	AIS_DO_SHIP_STUFF = 19,

    49

	AIS_SELL_VEHICLE = 20,

    50

	AIS_REMOVE_STATION = 21,

    51

	AIS_REMOVE_TRACK = 22,

    52

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    53

};

    54

    55

    56

#include "../../table/ai_rail.h"

    57

    58

static byte GetRailTrackStatus(TileIndex tile) {

    59

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    60

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

    61

}

    62

    63

    64

static void AiCase0(Player *p)

    65

{

    66

	p->ai.state = AIS_REMOVE_TRACK;

    67

	p->ai.state_counter = 0;

    68

}

    69

    70

static void AiCase1(Player *p)

    71

{

    72

	p->ai.cur_veh = NULL;

    73

	p->ai.state = AIS_VEH_LOOP;

    74

}

    75

    76

static void AiStateVehLoop(Player *p)

    77

{

    78

	Vehicle *v;

    79

	uint index;

    80

    81

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

    82

    83

	FOR_ALL_VEHICLES_FROM(v, index) {

    84

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

    85

			continue;

    86

    87

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

    88

				v->type == VEH_Road ||

    89

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

    90

				v->type == VEH_Ship) {

    91

    92

			/* replace engine? */

    93

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

    94

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

    95

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

    96

				p->ai.cur_veh = v;

    97

				return;

    98

			}

    99

   100

			/* not profitable? */

   101

			if (v->age >= 730 &&

   102

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

   103

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

   104

				p->ai.state_counter = 0;

   105

				p->ai.state = AIS_SELL_VEHICLE;

   106

				p->ai.cur_veh = v;

   107

				return;

   108

			}

   109

   110

			/* not reliable? */

   111

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

   112

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

   113

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

   114

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   115

				p->ai.cur_veh = v;

   116

				return;

   117

			}

   118

		}

   119

	}

   120

   121

	p->ai.state = AIS_WANT_NEW_ROUTE;

   122

	p->ai.state_counter = 0;

   123

}

   124

   125

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

   126

{

   127

	int best_veh_index = -1;

   128

	byte best_veh_score = 0;

   129

	int32 ret;

   130

	int i;

   131

   132

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

   133

		const RailVehicleInfo *rvi = RailVehInfo(i);

   134

		const Engine* e = GetEngine(i);

   135

   136

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

   137

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

   138

			continue;

   139

   140

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

   141

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

   142

				_cmd_build_rail_veh_score >= best_veh_score) {

   143

			best_veh_score = _cmd_build_rail_veh_score;

   144

			best_veh_index = i;

   145

		}

   146

	}

   147

   148

	return best_veh_index;

   149

}

   150

   151

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

   152

{

   153

	int best_veh_index = -1;

   154

	int32 best_veh_cost = 0;

   155

	int32 ret;

   156

   157

	int i = _cargoc.ai_roadveh_start[cargo];

   158

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

   159

	const Engine* e = GetEngine(i);

   160

   161

	do {

   162

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

   163

			continue;

   164

   165

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

   166

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

   167

			best_veh_cost = ret;

   168

			best_veh_index = i;

   169

		}

   170

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

   171

   172

	return best_veh_index;

   173

}

   174

   175

static int AiChooseAircraftToBuild(int32 money, byte flag)

   176

{

   177

	int best_veh_index = -1;

   178

	int32 best_veh_cost = 0;

   179

	int32 ret;

   180

   181

	int i = AIRCRAFT_ENGINES_INDEX;

   182

	int end = i + NUM_AIRCRAFT_ENGINES;

   183

	const Engine* e = GetEngine(i);

   184

   185

	do {

   186

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

   187

			continue;

   188

   189

		if (flag&1) {

   190

			if (i<253) continue;

   191

		} else {

   192

			if (i>=253) continue;

   193

		}

   194

   195

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

   196

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

   197

			best_veh_cost = ret;

   198

			best_veh_index = i;

   199

		}

   200

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

   201

   202

	return best_veh_index;

   203

}

   204

   205

static int32 AiGetBasePrice(Player *p)

   206

{

   207

	int32 base = _price.station_value;

   208

   209

	// adjust base price when more expensive vehicles are available

   210

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

   211

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

   212

   213

	return base;

   214

}

   215

   216

#if 0

   217

static int AiChooseShipToBuild(byte cargo, int32 money)

   218

{

   219

	// XXX: not done

   220

	return 0;

   221

}

   222

#endif

   223

   224

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

   225

{

   226

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

   227

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

   228

}

   229

   230

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

   231

{

   232

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

   233

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

   234

}

   235

   236

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

   237

{

   238

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

   239

	int num=0;

   240

	Vehicle *u = v;

   241

   242

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

   243

		u = u->next;

   244

	}

   245

   246

	// XXX: check if a wagon

   247

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

   248

}

   249

   250

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

   251

{

   252

	error("!AiChooseShipToReplaceWith");

   253

   254

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

   255

	return 0;

   256

}

   257

   258

static void AiHandleGotoDepot(Player *p, int cmd)

   259

{

   260

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

   261

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

   262

   263

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

   264

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   265

		return;

   266

	}

   267

   268

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

   269

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

   270

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

   271

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

   272

	}

   273

}

   274

   275

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

   276

{

   277

	int i;

   278

   279

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

   280

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

   281

			break;

   282

}

   283

   284

static void AiHandleReplaceTrain(Player *p)

   285

{

   286

	Vehicle *v = p->ai.cur_veh;

   287

	BackuppedOrders orderbak[1];

   288

	int veh;

   289

   290

	// wait until the vehicle reaches the depot.

   291

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

   292

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   293

		return;

   294

	}

   295

   296

	veh = AiChooseTrainToReplaceWith(p, v);

   297

	if (veh != -1) {

   298

		TileIndex tile;

   299

   300

		BackupVehicleOrders(v, orderbak);

   301

		tile = v->tile;

   302

   303

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

   304

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

   305

			veh = _new_train_id;

   306

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   307

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

   308

   309

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

   310

		}

   311

	}

   312

}

   313

   314

static void AiHandleReplaceRoadVeh(Player *p)

   315

{

   316

	Vehicle *v = p->ai.cur_veh;

   317

	BackuppedOrders orderbak[1];

   318

	int veh;

   319

   320

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

   321

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   322

		return;

   323

	}

   324

   325

	veh = AiChooseRoadVehToReplaceWith(p, v);

   326

	if (veh != -1) {

   327

		TileIndex tile;

   328

   329

		BackupVehicleOrders(v, orderbak);

   330

		tile = v->tile;

   331

   332

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

   333

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

   334

			veh = _new_roadveh_id;

   335

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   336

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

   337

   338

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

   339

		}

   340

	}

   341

}

   342

   343

static void AiHandleReplaceAircraft(Player *p)

   344

{

   345

	Vehicle *v = p->ai.cur_veh;

   346

	int veh;

   347

	BackuppedOrders orderbak[1];

   348

   349

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

   350

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   351

		return;

   352

	}

   353

   354

	veh = AiChooseAircraftToReplaceWith(p, v);

   355

	if (veh != -1) {

   356

		TileIndex tile;

   357

   358

		BackupVehicleOrders(v, orderbak);

   359

		tile = v->tile;

   360

   361

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

   362

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

   363

			veh = _new_aircraft_id;

   364

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   365

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

   366

   367

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

   368

		}

   369

	}

   370

}

   371

   372

static void AiHandleReplaceShip(Player *p)

   373

{

   374

	error("!AiHandleReplaceShip");

   375

}

   376

   377

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

   378

   379

static CheckReplaceProc * const _veh_check_replace_proc[] = {

   380

	AiChooseTrainToReplaceWith,

   381

	AiChooseRoadVehToReplaceWith,

   382

	AiChooseShipToReplaceWith,

   383

	AiChooseAircraftToReplaceWith,

   384

};

   385

   386

typedef void DoReplaceProc(Player *p);

   387

static DoReplaceProc * const _veh_do_replace_proc[] = {

   388

	AiHandleReplaceTrain,

   389

	AiHandleReplaceRoadVeh,

   390

	AiHandleReplaceShip,

   391

	AiHandleReplaceAircraft

   392

};

   393

   394

static void AiStateCheckReplaceVehicle(Player *p)

   395

{

   396

	Vehicle *v = p->ai.cur_veh;

   397

   398

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

   399

		p->ai.state = AIS_VEH_LOOP;

   400

	} else {

   401

		p->ai.state_counter = 0;

   402

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   403

	}

   404

}

   405

   406

static void AiStateDoReplaceVehicle(Player *p)

   407

{

   408

	Vehicle *v = p->ai.cur_veh;

   409

	p->ai.state = AIS_VEH_LOOP;

   410

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

   411

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

   412

		return;

   413

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

   414

}

   415

   416

typedef struct FoundRoute {

   417

	int distance;

   418

	byte cargo;

   419

	void *from;

   420

	void *to;

   421

} FoundRoute;

   422

   423

static Town *AiFindRandomTown(void)

   424

{

   425

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

   426

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

   427

}

   428

   429

static Industry *AiFindRandomIndustry(void)

   430

{

   431

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

   432

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

   433

}

   434

   435

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   436

{

   437

	uint i;

   438

	byte cargo;

   439

	Subsidy *s;

   440

	Industry *from, *to_ind;

   441

	Town *to_tow;

   442

	TileIndex to_xy;

   443

   444

	// initially error

   445

	fr->distance = -1;

   446

   447

	// Randomize subsidy index..

   448

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

   449

	if (i >= lengthof(_subsidies))

   450

		return;

   451

   452

	s = &_subsidies[i];

   453

   454

	// Don't want passengers or mail

   455

	cargo = s->cargo_type;

   456

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

   457

		return;

   458

	fr->cargo = cargo;

   459

   460

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

   461

   462

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

   463

		to_tow = GetTown(s->to);

   464

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

   465

			return; // error

   466

		fr->to = to_tow;

   467

		to_xy = to_tow->xy;

   468

	} else {

   469

		to_ind = GetIndustry(s->to);

   470

		fr->to = to_ind;

   471

		to_xy = to_ind->xy;

   472

	}

   473

   474

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

   475

}

   476

   477

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   478

{

   479

	uint i;

   480

	Subsidy *s;

   481

	Town *from,*to;

   482

   483

	// initially error

   484

	fr->distance = -1;

   485

   486

	// Randomize subsidy index..

   487

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

   488

	if (i >= lengthof(_subsidies))

   489

		return;

   490

   491

	s = &_subsidies[i];

   492

   493

	// Only want passengers

   494

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

   495

		return;

   496

	fr->cargo = s->cargo_type;

   497

   498

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

   499

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

   500

   501

	// They must be big enough

   502

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

   503

		return;

   504

   505

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

   506

}

   507

   508

static void AiFindRandomIndustryRoute(FoundRoute *fr)

   509

{

   510

	Industry *i,*i2;

   511

	Town *t;

   512

	uint32 r;

   513

	byte cargo;

   514

   515

	// initially error

   516

	fr->distance = -1;

   517

   518

	r = Random();

   519

   520

	// pick a source

   521

	fr->from = i = AiFindRandomIndustry();

   522

	if (i == NULL)

   523

		return;

   524

   525

	// pick a random produced cargo

   526

	cargo = i->produced_cargo[0];

   527

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

   528

		cargo = i->produced_cargo[1];

   529