1

/* $Id$ */

     2

     3

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

     4

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

     5

#include "../../bridge_map.h"

     6

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

     7

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

     8

#include "../../rail_map.h"

     9

#include "../../road_map.h"

    10

#include "../../station_map.h"

    11

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

    12

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

    13

#include "../../tunnel_map.h"

    14

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

    15

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

    16

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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

#include "../../bridge.h"

    26

#include "default.h"

    27

    28

// remove some day perhaps?

    29

static Player *_cur_ai_player;

    30

static uint _ai_service_interval;

    31

    32

typedef void AiStateAction(Player *p);

    33

    34

enum {

    35

	AIS_0 = 0,

    36

	AIS_1 = 1,

    37

	AIS_VEH_LOOP = 2,

    38

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    39

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    40

	AIS_WANT_NEW_ROUTE = 5,

    41

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    42

	AIS_BUILD_RAIL = 7,

    43

	AIS_BUILD_RAIL_VEH = 8,

    44

	AIS_DELETE_RAIL_BLOCKS = 9,

    45

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    46

	AIS_BUILD_ROAD = 11,

    47

	AIS_BUILD_ROAD_VEHICLES = 12,

    48

	AIS_DELETE_ROAD_BLOCKS = 13,

    49

	AIS_AIRPORT_STUFF = 14,

    50

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    51

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    52

	AIS_CHECK_SHIP_STUFF = 17,

    53

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    54

	AIS_DO_SHIP_STUFF = 19,

    55

	AIS_SELL_VEHICLE = 20,

    56

	AIS_REMOVE_STATION = 21,

    57

	AIS_REMOVE_TRACK = 22,

    58

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    59

};

    60

    61

    62

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

    63

    64

static byte GetRailTrackStatus(TileIndex tile)

    65

{

    66

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    67

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

    68

}

    69

    70

    71

static void AiCase0(Player *p)

    72

{

    73

	p->ai.state = AIS_REMOVE_TRACK;

    74

	p->ai.state_counter = 0;

    75

}

    76

    77

static void AiCase1(Player *p)

    78

{

    79

	p->ai.cur_veh = NULL;

    80

	p->ai.state = AIS_VEH_LOOP;

    81

}

    82

    83

static void AiStateVehLoop(Player *p)

    84

{

    85

	Vehicle *v;

    86

	uint index;

    87

    88

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

    89

    90

	FOR_ALL_VEHICLES_FROM(v, index) {

    91

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

    92

    93

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

    94

				v->type == VEH_Road ||

    95

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

    96

				v->type == VEH_Ship) {

    97

			/* replace engine? */

    98

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

    99

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

   100

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   101

				p->ai.cur_veh = v;

   102

				return;

   103

			}

   104

   105

			/* not profitable? */

   106

			if (v->age >= 730 &&

   107

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

   108

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

   109

				p->ai.state_counter = 0;

   110

				p->ai.state = AIS_SELL_VEHICLE;

   111

				p->ai.cur_veh = v;

   112

				return;

   113

			}

   114

   115

			/* not reliable? */

   116

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

   117

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

   118

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

   119

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   120

				p->ai.cur_veh = v;

   121

				return;

   122

			}

   123

		}

   124

	}

   125

   126

	p->ai.state = AIS_WANT_NEW_ROUTE;

   127

	p->ai.state_counter = 0;

   128

}

   129

   130

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

   131

{

   132

	EngineID best_veh_index = INVALID_ENGINE;

   133

	byte best_veh_score = 0;

   134

	int32 ret;

   135

	EngineID i;

   136

   137

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

   138

		const RailVehicleInfo *rvi = RailVehInfo(i);

   139

		const Engine* e = GetEngine(i);

   140

   141

		if (!IsCompatibleRail(e->railtype, railtype) ||

   142

				rvi->flags & RVI_WAGON ||

   143

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

   144

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

   145

				e->reliability < 0x8A3D) {

   146

			continue;

   147

		}

   148

   149

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

   150

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

   151

				rvi->ai_rank >= best_veh_score) {

   152

			best_veh_score = rvi->ai_rank;

   153

			best_veh_index = i;

   154

		}

   155

	}

   156

   157

	return best_veh_index;

   158

}

   159

   160

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

   161

{

   162

	EngineID best_veh_index = INVALID_ENGINE;

   163

	int32 best_veh_cost = 0;

   164

	int32 ret;

   165

   166

	EngineID i = _cargoc.ai_roadveh_start[cargo];

   167

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

   168

   169

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

   170

		const Engine* e = GetEngine(i);

   171

   172

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

   173

			continue;

   174

   175

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

   176

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

   177

			best_veh_cost = ret;

   178

			best_veh_index = i;

   179

		}

   180

	}

   181

   182

	return best_veh_index;

   183

}

   184

   185

static EngineID AiChooseAircraftToBuild(int32 money, byte flag)

   186

{

   187

	EngineID best_veh_index = INVALID_ENGINE;

   188

	int32 best_veh_cost = 0;

   189

	int32 ret;

   190

   191

	EngineID i = AIRCRAFT_ENGINES_INDEX;

   192

	EngineID end = i + NUM_AIRCRAFT_ENGINES;

   193

   194

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

   195

		const Engine* e = GetEngine(i);

   196

   197

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

   198

			continue;

   199

   200

		if (flag&1) {

   201

			if (i<253) continue;

   202

		} else {

   203

			if (i>=253) continue;

   204

		}

   205

   206

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

   207

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

   208

			best_veh_cost = ret;

   209

			best_veh_index = i;

   210

		}

   211

	}

   212

   213

	return best_veh_index;

   214

}

   215

   216

static int32 AiGetBasePrice(Player *p)

   217

{

   218

	int32 base = _price.station_value;

   219

   220

	// adjust base price when more expensive vehicles are available

   221

	switch (p->ai.railtype_to_use) {

   222

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

   223

		case 2: base *= 2; break;

   224

	}

   225

   226

	return base;

   227

}

   228

   229

#if 0

   230

static EngineID AiChooseShipToBuild(byte cargo, int32 money)

   231

{

   232

	// XXX: not done

   233

	return INVALID_ENGINE;

   234

}

   235

#endif

   236

   237

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

   238

{

   239

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

   240

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

   241

}

   242

   243

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

   244

{

   245

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

   246

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

   247

}

   248

   249

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

   250

{

   251

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

   252

	int num=0;

   253

	Vehicle *u = v;

   254

   255

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

   256

		u = u->next;

   257

	}

   258

   259

	// XXX: check if a wagon

   260

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

   261

}

   262

   263

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

   264

{

   265

	error("!AiChooseShipToReplaceWith");

   266

   267

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

   268

	return INVALID_ENGINE;

   269

}

   270

   271

static void AiHandleGotoDepot(Player *p, int cmd)

   272

{

   273

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

   274

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

   275

   276

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

   277

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   278

		return;

   279

	}

   280

   281

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

   282

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

   283

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

   284

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

   285

	}

   286

}

   287

   288

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

   289

{

   290

	uint i;

   291

   292

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

   293

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

   294

			break;

   295

	}

   296

}

   297

   298

static void AiHandleReplaceTrain(Player *p)

   299

{

   300

	Vehicle *v = p->ai.cur_veh;

   301

	BackuppedOrders orderbak[1];

   302

	EngineID veh;

   303

   304

	// wait until the vehicle reaches the depot.

   305

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

   306

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   307

		return;

   308

	}

   309

   310

	veh = AiChooseTrainToReplaceWith(p, v);

   311

	if (veh != INVALID_ENGINE) {

   312

		TileIndex tile;

   313

   314

		BackupVehicleOrders(v, orderbak);

   315

		tile = v->tile;

   316

   317

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

   318

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

   319

			VehicleID veh = _new_train_id;

   320

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   321

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

   322

   323

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

   324

		}

   325

	}

   326

}

   327

   328

static void AiHandleReplaceRoadVeh(Player *p)

   329

{

   330

	Vehicle *v = p->ai.cur_veh;

   331

	BackuppedOrders orderbak[1];

   332

	EngineID veh;

   333

   334

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

   335

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   336

		return;

   337

	}

   338

   339

	veh = AiChooseRoadVehToReplaceWith(p, v);

   340

	if (veh != INVALID_ENGINE) {

   341

		TileIndex tile;

   342

   343

		BackupVehicleOrders(v, orderbak);

   344

		tile = v->tile;

   345

   346

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

   347

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

   348

			VehicleID veh = _new_roadveh_id;

   349

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   350

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

   351

   352

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

   353

		}

   354

	}

   355

}

   356

   357

static void AiHandleReplaceAircraft(Player *p)

   358

{

   359

	Vehicle *v = p->ai.cur_veh;

   360

	BackuppedOrders orderbak[1];

   361

	EngineID veh;

   362

   363

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

   364

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   365

		return;

   366

	}

   367

   368

	veh = AiChooseAircraftToReplaceWith(p, v);

   369

	if (veh != INVALID_ENGINE) {

   370

		TileIndex tile;

   371

   372

		BackupVehicleOrders(v, orderbak);

   373

		tile = v->tile;

   374

   375

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

   376

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

   377

			VehicleID veh = _new_aircraft_id;

   378

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   379

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

   380

   381

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

   382

		}

   383

	}

   384

}

   385

   386

static void AiHandleReplaceShip(Player *p)

   387

{

   388

	error("!AiHandleReplaceShip");

   389

}

   390

   391

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

   392

   393

static CheckReplaceProc* const _veh_check_replace_proc[] = {

   394

	AiChooseTrainToReplaceWith,

   395

	AiChooseRoadVehToReplaceWith,

   396

	AiChooseShipToReplaceWith,

   397

	AiChooseAircraftToReplaceWith,

   398

};

   399

   400

typedef void DoReplaceProc(Player *p);

   401

static DoReplaceProc* const _veh_do_replace_proc[] = {

   402

	AiHandleReplaceTrain,

   403

	AiHandleReplaceRoadVeh,

   404

	AiHandleReplaceShip,

   405

	AiHandleReplaceAircraft

   406

};

   407

   408

static void AiStateCheckReplaceVehicle(Player *p)

   409

{

   410

	Vehicle *v = p->ai.cur_veh;

   411

   412

	if (v->type == 0 ||

   413

			v->owner != _current_player ||

   414

			v->type > VEH_Ship ||

   415

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

   416

		p->ai.state = AIS_VEH_LOOP;

   417

	} else {

   418

		p->ai.state_counter = 0;

   419

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   420

	}

   421

}

   422

   423

static void AiStateDoReplaceVehicle(Player *p)

   424

{

   425

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

   426

   427

	p->ai.state = AIS_VEH_LOOP;

   428

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

   429

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

   430

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

   431

}

   432

   433

typedef struct FoundRoute {

   434

	int distance;

   435

	CargoID cargo;

   436

	void *from;

   437

	void *to;

   438

} FoundRoute;

   439

   440

static Town *AiFindRandomTown(void)

   441

{

   442

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

   443

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

   444

}

   445

   446

static Industry *AiFindRandomIndustry(void)

   447

{

   448

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

   449

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

   450

}

   451

   452

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   453

{

   454

	uint i;

   455

	CargoID cargo;

   456

	Subsidy *s;

   457

	Industry *from, *to_ind;

   458

	Town *to_tow;

   459

	TileIndex to_xy;

   460

   461

	// initially error

   462

	fr->distance = -1;

   463

   464

	// Randomize subsidy index..

   465

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

   466

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

   467

   468

	s = &_subsidies[i];

   469

   470

	// Don't want passengers or mail

   471

	cargo = s->cargo_type;

   472

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

   473

		return;

   474

	fr->cargo = cargo;

   475

   476

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

   477

   478

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

   479

		to_tow = GetTown(s->to);

   480

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

   481

			return; // error

   482

		fr->to = to_tow;

   483

		to_xy = to_tow->xy;

   484

	} else {

   485

		to_ind = GetIndustry(s->to);

   486

		fr->to = to_ind;

   487

		to_xy = to_ind->xy;

   488

	}

   489

   490

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

   491

}

   492

   493

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   494

{

   495

	uint i;

   496

	Subsidy *s;

   497

	Town *from,*to;

   498

   499

	// initially error

   500

	fr->distance = -1;

   501

   502

	// Randomize subsidy index..

   503

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

   504

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

   505