1

/* $Id$ */

     2

     3

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

     4

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

     5

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

     6

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

     7

#include "../../road.h"

     8

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

     9

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

    10

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

    11

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

    12

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

    13

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

    14

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

    15

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

    16

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

    17

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

    18

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

    19

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

    20

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

    21

#include "default.h"

    22

    23

// remove some day perhaps?

    24

static Player *_cur_ai_player;

    25

static uint _ai_service_interval;

    26

    27

typedef void AiStateAction(Player *p);

    28

    29

enum {

    30

	AIS_0 = 0,

    31

	AIS_1 = 1,

    32

	AIS_VEH_LOOP = 2,

    33

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    34

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    35

	AIS_WANT_NEW_ROUTE = 5,

    36

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    37

	AIS_BUILD_RAIL = 7,

    38

	AIS_BUILD_RAIL_VEH = 8,

    39

	AIS_DELETE_RAIL_BLOCKS = 9,

    40

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    41

	AIS_BUILD_ROAD = 11,

    42

	AIS_BUILD_ROAD_VEHICLES = 12,

    43

	AIS_DELETE_ROAD_BLOCKS = 13,

    44

	AIS_AIRPORT_STUFF = 14,

    45

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    46

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    47

	AIS_CHECK_SHIP_STUFF = 17,

    48

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    49

	AIS_DO_SHIP_STUFF = 19,

    50

	AIS_SELL_VEHICLE = 20,

    51

	AIS_REMOVE_STATION = 21,

    52

	AIS_REMOVE_TRACK = 22,

    53

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    54

};

    55

    56

    57

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

    58

    59

static byte GetRailTrackStatus(TileIndex tile)

    60

{

    61

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    62

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

    63

}

    64

    65

    66

static void AiCase0(Player *p)

    67

{

    68

	p->ai.state = AIS_REMOVE_TRACK;

    69

	p->ai.state_counter = 0;

    70

}

    71

    72

static void AiCase1(Player *p)

    73

{

    74

	p->ai.cur_veh = NULL;

    75

	p->ai.state = AIS_VEH_LOOP;

    76

}

    77

    78

static void AiStateVehLoop(Player *p)

    79

{

    80

	Vehicle *v;

    81

	uint index;

    82

    83

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

    84

    85

	FOR_ALL_VEHICLES_FROM(v, index) {

    86

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

    87

    88

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

    89

				v->type == VEH_Road ||

    90

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

    91

				v->type == VEH_Ship) {

    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 EngineID AiChooseTrainToBuild(byte railtype, int32 money, byte flag, TileIndex tile)

   126

{

   127

	EngineID best_veh_index = INVALID_ENGINE;

   128

	byte best_veh_score = 0;

   129

	int32 ret;

   130

	EngineID 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 ||

   137

				rvi->flags & RVI_WAGON ||

   138

				(rvi->flags & RVI_MULTIHEAD && flag & 1) ||

   139

				!HASBIT(e->player_avail, _current_player) ||

   140

				e->reliability < 0x8A3D) {

   141

			continue;

   142

		}

   143

   144

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

   145

		if (!CmdFailed(ret) && ret <= money &&

   146

				rvi->ai_rank >= best_veh_score) {

   147

			best_veh_score = rvi->ai_rank;

   148

			best_veh_index = i;

   149

		}

   150

	}

   151

   152

	return best_veh_index;

   153

}

   154

   155

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

   156

{

   157

	EngineID best_veh_index = INVALID_ENGINE;

   158

	int32 best_veh_cost = 0;

   159

	int32 ret;

   160

   161

	EngineID i = _cargoc.ai_roadveh_start[cargo];

   162

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

   163

   164

	for (; i != end; i++) {

   165

		const Engine* e = GetEngine(i);

   166

   167

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

   168

			continue;

   169

   170

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

   171

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

   172

			best_veh_cost = ret;

   173

			best_veh_index = i;

   174

		}

   175

	}

   176

   177

	return best_veh_index;

   178

}

   179

   180

static EngineID AiChooseAircraftToBuild(int32 money, byte flag)

   181

{

   182

	EngineID best_veh_index = INVALID_ENGINE;

   183

	int32 best_veh_cost = 0;

   184

	int32 ret;

   185

   186

	EngineID i = AIRCRAFT_ENGINES_INDEX;

   187

	EngineID end = i + NUM_AIRCRAFT_ENGINES;

   188

   189

	for (; i != end; i++) {

   190

		const Engine* e = GetEngine(i);

   191

   192

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

   193

			continue;

   194

   195

		if (flag&1) {

   196

			if (i<253) continue;

   197

		} else {

   198

			if (i>=253) continue;

   199

		}

   200

   201

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

   202

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

   203

			best_veh_cost = ret;

   204

			best_veh_index = i;

   205

		}

   206

	}

   207

   208

	return best_veh_index;

   209

}

   210

   211

static int32 AiGetBasePrice(Player *p)

   212

{

   213

	int32 base = _price.station_value;

   214

   215

	// adjust base price when more expensive vehicles are available

   216

	switch (p->ai.railtype_to_use) {

   217

		case 1: base = (base * 3) >> 1; break;

   218

		case 2: base *= 2; break;

   219

	}

   220

   221

	return base;

   222

}

   223

   224

#if 0

   225

static EngineID AiChooseShipToBuild(byte cargo, int32 money)

   226

{

   227

	// XXX: not done

   228

	return INVALID_ENGINE;

   229

}

   230

#endif

   231

   232

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

   233

{

   234

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

   235

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

   236

}

   237

   238

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

   239

{

   240

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

   241

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

   242

}

   243

   244

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

   245

{

   246

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

   247

	int num=0;

   248

	Vehicle *u = v;

   249

   250

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

   251

		u = u->next;

   252

	}

   253

   254

	// XXX: check if a wagon

   255

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

   256

}

   257

   258

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

   259

{

   260

	error("!AiChooseShipToReplaceWith");

   261

   262

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

   263

	return INVALID_ENGINE;

   264

}

   265

   266

static void AiHandleGotoDepot(Player *p, int cmd)

   267

{

   268

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

   269

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

   270

   271

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

   272

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   273

		return;

   274

	}

   275

   276

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

   277

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

   278

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

   279

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

   280

	}

   281

}

   282

   283

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

   284

{

   285

	uint i;

   286

   287

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

   288

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

   289

			break;

   290

	}

   291

}

   292

   293

static void AiHandleReplaceTrain(Player *p)

   294

{

   295

	Vehicle *v = p->ai.cur_veh;

   296

	BackuppedOrders orderbak[1];

   297

	EngineID veh;

   298

   299

	// wait until the vehicle reaches the depot.

   300

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

   301

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   302

		return;

   303

	}

   304

   305

	veh = AiChooseTrainToReplaceWith(p, v);

   306

	if (veh != INVALID_ENGINE) {

   307

		TileIndex tile;

   308

   309

		BackupVehicleOrders(v, orderbak);

   310

		tile = v->tile;

   311

   312

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

   313

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

   314

			VehicleID veh = _new_train_id;

   315

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   316

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

   317

   318

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

   319

		}

   320

	}

   321

}

   322

   323

static void AiHandleReplaceRoadVeh(Player *p)

   324

{

   325

	Vehicle *v = p->ai.cur_veh;

   326

	BackuppedOrders orderbak[1];

   327

	EngineID veh;

   328

   329

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

   330

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   331

		return;

   332

	}

   333

   334

	veh = AiChooseRoadVehToReplaceWith(p, v);

   335

	if (veh != INVALID_ENGINE) {

   336

		TileIndex tile;

   337

   338

		BackupVehicleOrders(v, orderbak);

   339

		tile = v->tile;

   340

   341

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

   342

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

   343

			VehicleID veh = _new_roadveh_id;

   344

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   345

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

   346

   347

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

   348

		}

   349

	}

   350

}

   351

   352

static void AiHandleReplaceAircraft(Player *p)

   353

{

   354

	Vehicle *v = p->ai.cur_veh;

   355

	BackuppedOrders orderbak[1];

   356

	EngineID veh;

   357

   358

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

   359

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   360

		return;

   361

	}

   362

   363

	veh = AiChooseAircraftToReplaceWith(p, v);

   364

	if (veh != INVALID_ENGINE) {

   365

		TileIndex tile;

   366

   367

		BackupVehicleOrders(v, orderbak);

   368

		tile = v->tile;

   369

   370

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

   371

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

   372

			VehicleID veh = _new_aircraft_id;

   373

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   374

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

   375

   376

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

   377

		}

   378

	}

   379

}

   380

   381

static void AiHandleReplaceShip(Player *p)

   382

{

   383

	error("!AiHandleReplaceShip");

   384

}

   385

   386

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

   387

   388

static CheckReplaceProc* const _veh_check_replace_proc[] = {

   389

	AiChooseTrainToReplaceWith,

   390

	AiChooseRoadVehToReplaceWith,

   391

	AiChooseShipToReplaceWith,

   392

	AiChooseAircraftToReplaceWith,

   393

};

   394

   395

typedef void DoReplaceProc(Player *p);

   396

static DoReplaceProc* const _veh_do_replace_proc[] = {

   397

	AiHandleReplaceTrain,

   398

	AiHandleReplaceRoadVeh,

   399

	AiHandleReplaceShip,

   400

	AiHandleReplaceAircraft

   401

};

   402

   403

static void AiStateCheckReplaceVehicle(Player *p)

   404

{

   405

	Vehicle *v = p->ai.cur_veh;

   406

   407

	if (v->type == 0 ||

   408

			v->owner != _current_player ||

   409

			v->type > VEH_Ship ||

   410

			_veh_check_replace_proc[v->type - VEH_Train](p, v) == INVALID_ENGINE) {

   411

		p->ai.state = AIS_VEH_LOOP;

   412

	} else {

   413

		p->ai.state_counter = 0;

   414

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   415

	}

   416

}

   417

   418

static void AiStateDoReplaceVehicle(Player *p)

   419

{

   420

	const Vehicle* v = p->ai.cur_veh;

   421

   422

	p->ai.state = AIS_VEH_LOOP;

   423

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

   424

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

   425

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

   426

}

   427

   428

typedef struct FoundRoute {

   429

	int distance;

   430

	byte cargo;

   431

	void *from;

   432

	void *to;

   433

} FoundRoute;

   434

   435

static Town *AiFindRandomTown(void)

   436

{

   437

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

   438

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

   439

}

   440

   441

static Industry *AiFindRandomIndustry(void)

   442

{

   443

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

   444

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

   445

}

   446

   447

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   448

{

   449

	uint i;

   450

	byte cargo;

   451

	Subsidy *s;

   452

	Industry *from, *to_ind;

   453

	Town *to_tow;

   454

	TileIndex to_xy;

   455

   456

	// initially error

   457

	fr->distance = -1;

   458

   459

	// Randomize subsidy index..

   460

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

   461

	if (i >= lengthof(_subsidies)) return;

   462

   463

	s = &_subsidies[i];

   464

   465

	// Don't want passengers or mail

   466

	cargo = s->cargo_type;

   467

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

   468

		return;

   469

	fr->cargo = cargo;

   470

   471

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

   472

   473

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

   474

		to_tow = GetTown(s->to);

   475

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

   476

			return; // error

   477

		fr->to = to_tow;

   478

		to_xy = to_tow->xy;

   479

	} else {

   480

		to_ind = GetIndustry(s->to);

   481

		fr->to = to_ind;

   482

		to_xy = to_ind->xy;

   483

	}

   484

   485

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

   486

}

   487

   488

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   489

{

   490

	uint i;

   491

	Subsidy *s;

   492

	Town *from,*to;

   493

   494

	// initially error

   495

	fr->distance = -1;

   496

   497

	// Randomize subsidy index..

   498

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

   499

	if (i >= lengthof(_subsidies)) return;

   500

   501

	s = &_subsidies[i];

   502

   503

	// Only want passengers

   504

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

   505

	fr->cargo = s->cargo_type;

   506