1

/* $Id$ */

     2

     3

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

     4

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

     5

#include "../../aircraft.h"

     6

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

     7

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

     8

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

     9

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

    10

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

    11

#include "../../roadveh.h"

    12

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

    13

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

    14

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

    15

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

    16

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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

#include "default.h"

    29

    30

// remove some day perhaps?

    31

static uint _ai_service_interval;

    32

    33

typedef void AiStateAction(Player *p);

    34

    35

enum {

    36

	AIS_0 = 0,

    37

	AIS_1 = 1,

    38

	AIS_VEH_LOOP = 2,

    39

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    40

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    41

	AIS_WANT_NEW_ROUTE = 5,

    42

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    43

	AIS_BUILD_RAIL = 7,

    44

	AIS_BUILD_RAIL_VEH = 8,

    45

	AIS_DELETE_RAIL_BLOCKS = 9,

    46

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    47

	AIS_BUILD_ROAD = 11,

    48

	AIS_BUILD_ROAD_VEHICLES = 12,

    49

	AIS_DELETE_ROAD_BLOCKS = 13,

    50

	AIS_AIRPORT_STUFF = 14,

    51

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    52

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    53

	AIS_CHECK_SHIP_STUFF = 17,

    54

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    55

	AIS_DO_SHIP_STUFF = 19,

    56

	AIS_SELL_VEHICLE = 20,

    57

	AIS_REMOVE_STATION = 21,

    58

	AIS_REMOVE_TRACK = 22,

    59

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    60

};

    61

    62

    63

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

    64

    65

static byte GetRailTrackStatus(TileIndex tile)

    66

{

    67

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    68

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

    69

}

    70

    71

    72

static void AiCase0(Player *p)

    73

{

    74

	p->ai.state = AIS_REMOVE_TRACK;

    75

	p->ai.state_counter = 0;

    76

}

    77

    78

static void AiCase1(Player *p)

    79

{

    80

	p->ai.cur_veh = NULL;

    81

	p->ai.state = AIS_VEH_LOOP;

    82

}

    83

    84

static void AiStateVehLoop(Player *p)

    85

{

    86

	Vehicle *v;

    87

	uint index;

    88

    89

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

    90

    91

	FOR_ALL_VEHICLES_FROM(v, index) {

    92

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

    93

    94

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

    95

				v->type == VEH_Road ||

    96

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

    97

				v->type == VEH_Ship) {

    98

			/* replace engine? */

    99

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

   100

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

   101

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   102

				p->ai.cur_veh = v;

   103

				return;

   104

			}

   105

   106

			/* not profitable? */

   107

			if (v->age >= 730 &&

   108

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

   109

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

   110

				p->ai.state_counter = 0;

   111

				p->ai.state = AIS_SELL_VEHICLE;

   112

				p->ai.cur_veh = v;

   113

				return;

   114

			}

   115

   116

			/* not reliable? */

   117

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

   118

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

   119

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

   120

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   121

				p->ai.cur_veh = v;

   122

				return;

   123

			}

   124

		}

   125

	}

   126

   127

	p->ai.state = AIS_WANT_NEW_ROUTE;

   128

	p->ai.state_counter = 0;

   129

}

   130

   131

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

   132

{

   133

	EngineID best_veh_index = INVALID_ENGINE;

   134

	byte best_veh_score = 0;

   135

	int32 ret;

   136

	EngineID i;

   137

   138

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

   139

		const RailVehicleInfo *rvi = RailVehInfo(i);

   140

		const Engine* e = GetEngine(i);

   141

   142

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

   143

				rvi->flags & RVI_WAGON ||

   144

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

   145

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

   146

				e->reliability < 0x8A3D) {

   147

			continue;

   148

		}

   149

   150

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

   151

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

   152

				rvi->ai_rank >= best_veh_score) {

   153

			best_veh_score = rvi->ai_rank;

   154

			best_veh_index = i;

   155

		}

   156

	}

   157

   158

	return best_veh_index;

   159

}

   160

   161

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

   162

{

   163

	EngineID best_veh_index = INVALID_ENGINE;

   164

	int32 best_veh_cost = 0;

   165

	int32 ret;

   166

   167

	EngineID i = _cargoc.ai_roadveh_start[cargo];

   168

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

   169

   170

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

   171

		const Engine* e = GetEngine(i);

   172

   173

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

   174

			continue;

   175

   176

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

   177

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

   178

			best_veh_cost = ret;

   179

			best_veh_index = i;

   180

		}

   181

	}

   182

   183

	return best_veh_index;

   184

}

   185

   186

static EngineID AiChooseAircraftToBuild(int32 money, byte flag)

   187

{

   188

	EngineID best_veh_index = INVALID_ENGINE;

   189

	int32 best_veh_cost = 0;

   190

	int32 ret;

   191

   192

	EngineID i = AIRCRAFT_ENGINES_INDEX;

   193

	EngineID end = i + NUM_AIRCRAFT_ENGINES;

   194

   195

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

   196

		const Engine* e = GetEngine(i);

   197

   198

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

   199

			continue;

   200

   201

		if (flag&1) {

   202

			if (i<253) continue;

   203

		} else {

   204

			if (i>=253) continue;

   205

		}

   206

   207

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

   208

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

   209

			best_veh_cost = ret;

   210

			best_veh_index = i;

   211

		}

   212

	}

   213

   214

	return best_veh_index;

   215

}

   216

   217

static int32 AiGetBasePrice(Player *p)

   218

{

   219

	int32 base = _price.station_value;

   220

   221

	// adjust base price when more expensive vehicles are available

   222

	switch (p->ai.railtype_to_use) {

   223

		default: NOT_REACHED();

   224

		case RAILTYPE_RAIL:     break;

   225

		case RAILTYPE_ELECTRIC: break;

   226

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

   227

		case RAILTYPE_MAGLEV:   base *= 2; break;

   228

	}

   229

   230

	return base;

   231

}

   232

   233

#if 0

   234

static EngineID AiChooseShipToBuild(byte cargo, int32 money)

   235

{

   236

	// XXX: not done

   237

	return INVALID_ENGINE;

   238

}

   239

#endif

   240

   241

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

   242

{

   243

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

   244

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

   245

}

   246

   247

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

   248

{

   249

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

   250

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

   251

}

   252

   253

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

   254

{

   255

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

   256

	int num=0;

   257

	Vehicle *u = v;

   258

   259

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

   260

		u = u->next;

   261

	}

   262

   263

	// XXX: check if a wagon

   264

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

   265

}

   266

   267

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

   268

{

   269

	error("!AiChooseShipToReplaceWith");

   270

   271

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

   272

	return INVALID_ENGINE;

   273

}

   274

   275

static void AiHandleGotoDepot(Player *p, int cmd)

   276

{

   277

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

   278

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

   279

   280

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

   281

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   282

		return;

   283

	}

   284

   285

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

   286

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

   287

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

   288

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

   289

	}

   290

}

   291

   292

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

   293

{

   294

	uint i;

   295

   296

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

   297

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

   298

			break;

   299

	}

   300

}

   301

   302

static void AiHandleReplaceTrain(Player *p)

   303

{

   304

	Vehicle *v = p->ai.cur_veh;

   305

	BackuppedOrders orderbak[1];

   306

	EngineID veh;

   307

   308

	// wait until the vehicle reaches the depot.

   309

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

   310

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   311

		return;

   312

	}

   313

   314

	veh = AiChooseTrainToReplaceWith(p, v);

   315

	if (veh != INVALID_ENGINE) {

   316

		TileIndex tile;

   317

   318

		BackupVehicleOrders(v, orderbak);

   319

		tile = v->tile;

   320

   321

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

   322

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

   323

			VehicleID veh = _new_vehicle_id;

   324

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   325

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

   326

   327

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

   328

		}

   329

	}

   330

}

   331

   332

static void AiHandleReplaceRoadVeh(Player *p)

   333

{

   334

	Vehicle *v = p->ai.cur_veh;

   335

	BackuppedOrders orderbak[1];

   336

	EngineID veh;

   337

   338

	if (!IsRoadVehInDepotStopped(v)) {

   339

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   340

		return;

   341

	}

   342

   343

	veh = AiChooseRoadVehToReplaceWith(p, v);

   344

	if (veh != INVALID_ENGINE) {

   345

		TileIndex tile;

   346

   347

		BackupVehicleOrders(v, orderbak);

   348

		tile = v->tile;

   349

   350

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

   352

			VehicleID veh = _new_vehicle_id;

   354

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   355

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

   356

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

   357

		}

   358

	}

   359

}

   360

   361

static void AiHandleReplaceAircraft(Player *p)

   362

{

   363

	Vehicle *v = p->ai.cur_veh;

   364

	BackuppedOrders orderbak[1];

   365

	EngineID veh;

   366

   367

	if (!IsAircraftInHangarStopped(v)) {

   368

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   369

		return;

   370

	}

   371

   372

	veh = AiChooseAircraftToReplaceWith(p, v);

   373

	if (veh != INVALID_ENGINE) {

   374

		TileIndex tile;

   375

   376

		BackupVehicleOrders(v, orderbak);

   377

		tile = v->tile;

   378

   379

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

   380

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

   381

			VehicleID veh = _new_vehicle_id;

   382

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   383

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

   384

   385

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

   386

		}

   387

	}

   388

}

   389

   390

static void AiHandleReplaceShip(Player *p)

   391

{

   392

	error("!AiHandleReplaceShip");

   393

}

   394

   395

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

   396

   397

static CheckReplaceProc* const _veh_check_replace_proc[] = {

   398

	AiChooseTrainToReplaceWith,

   399

	AiChooseRoadVehToReplaceWith,

   400

	AiChooseShipToReplaceWith,

   401

	AiChooseAircraftToReplaceWith,

   402

};

   403

   404

typedef void DoReplaceProc(Player *p);

   405

static DoReplaceProc* const _veh_do_replace_proc[] = {

   406

	AiHandleReplaceTrain,

   407

	AiHandleReplaceRoadVeh,

   408

	AiHandleReplaceShip,

   409

	AiHandleReplaceAircraft

   410

};

   411

   412

static void AiStateCheckReplaceVehicle(Player *p)

   413

{

   414

	Vehicle *v = p->ai.cur_veh;

   415

   416

	if (v->type == 0 ||

   417

			v->owner != _current_player ||

   418

			v->type > VEH_Ship ||

   419

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

   420

		p->ai.state = AIS_VEH_LOOP;

   421

	} else {

   422

		p->ai.state_counter = 0;

   423

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   424

	}

   425

}

   426

   427

static void AiStateDoReplaceVehicle(Player *p)

   428

{

   429

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

   430

   431

	p->ai.state = AIS_VEH_LOOP;

   432

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

   433

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

   434

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

   435

}

   436

   437

typedef struct FoundRoute {

   438

	int distance;

   439

	CargoID cargo;

   440

	void *from;

   441

	void *to;

   442

} FoundRoute;

   443

   444

static Town *AiFindRandomTown(void)

   445

{

   446

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

   447

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

   448

}

   449

   450

static Industry *AiFindRandomIndustry(void)

   451

{

   452

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

   453

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

   454

}

   455

   456

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   457

{

   458

	uint i;

   459

	CargoID cargo;

   460

	Subsidy *s;

   461

	Industry *from, *to_ind;

   462

	Town *to_tow;

   463

	TileIndex to_xy;

   464

   465

	// initially error

   466

	fr->distance = -1;

   467

   468

	// Randomize subsidy index..

   469

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

   470

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

   471

   472

	s = &_subsidies[i];

   473

   474

	// Don't want passengers or mail

   475

	cargo = s->cargo_type;

   476

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

   477

		return;

   478

	fr->cargo = cargo;

   479

   480

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

   481

   482

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

   483

		to_tow = GetTown(s->to);

   484

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

   485

			return; // error

   486

		fr->to = to_tow;

   487

		to_xy = to_tow->xy;

   488

	} else {

   489

		to_ind = GetIndustry(s->to);

   490

		fr->to = to_ind;

   491

		to_xy = to_ind->xy;

   492

	}

   493

   494

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

   495

}

   496

   497

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   498

{

   499

	uint i;

   500

	Subsidy *s;

   501

	Town *from,*to;

   502

   503

	// initially error

   504

	fr->distance = -1;

   505