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 "../../date.h"

    29

#include "default.h"

    30

    31

// remove some day perhaps?

    32

static uint _ai_service_interval;

    33

    34

typedef void AiStateAction(Player *p);

    35

    36

enum {

    52

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    61

};

    62

    63

    64

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

    65

    66

static byte GetRailTrackStatus(TileIndex tile)

    67

{

    68

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    69

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

    70

}

    71

    72

    73

static void AiCase0(Player *p)

    74

{

    75

	p->ai.state = AIS_REMOVE_TRACK;

    76

	p->ai.state_counter = 0;

    77

}

    78

    79

static void AiCase1(Player *p)

    80

{

    81

	p->ai.cur_veh = NULL;

    82

	p->ai.state = AIS_VEH_LOOP;

    83

}

    84

    85

static void AiStateVehLoop(Player *p)

    86

{

    87

	Vehicle *v;

    88

	uint index;

    89

    90

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

    91

    92

	FOR_ALL_VEHICLES_FROM(v, index) {

    93

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

    94

    95

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

    96

				v->type == VEH_Road ||

    97

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

    98

				v->type == VEH_Ship) {

    99

			/* replace engine? */

   100

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

   101

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

   102

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   103

				p->ai.cur_veh = v;

   104

				return;

   105

			}

   106

   107

			/* not profitable? */

   108

			if (v->age >= 730 &&

   109

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

   110

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

   111

				p->ai.state_counter = 0;

   112

				p->ai.state = AIS_SELL_VEHICLE;

   113

				p->ai.cur_veh = v;

   114

				return;

   115

			}

   116

   117

			/* not reliable? */

   118

			if (v->age >= v->max_age || (

   119

						v->age != 0 &&

   120

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

   121

					)) {

   122

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   123

				p->ai.cur_veh = v;

   124

				return;

   125

			}

   126

		}

   127

	}

   128

   129

	p->ai.state = AIS_WANT_NEW_ROUTE;

   130

	p->ai.state_counter = 0;

   131

}

   132

   133

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

   134

{

   135

	EngineID best_veh_index = INVALID_ENGINE;

   136

	byte best_veh_score = 0;

   137

	int32 ret;

   138

	EngineID i;

   139

   140

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

   141

		const RailVehicleInfo *rvi = RailVehInfo(i);

   142

		const Engine* e = GetEngine(i);

   143

   144

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

   145

				rvi->flags & RVI_WAGON ||

   146

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

   147

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

   148

				e->reliability < 0x8A3D) {

   149

			continue;

   150

		}

   151

   152

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

   153

		if (!CmdFailed(ret) && ret <= money && rvi->ai_rank >= best_veh_score) {

   154

			best_veh_score = rvi->ai_rank;

   155

			best_veh_index = i;

   156

		}

   157

	}

   158

   159

	return best_veh_index;

   160

}

   161

   162

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

   163

{

   164

	EngineID best_veh_index = INVALID_ENGINE;

   165

	int32 best_veh_cost = 0;

   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

		int32 ret;

   172

   173

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

   174

			continue;

   175

		}

   176

   177

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

   178

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

   179

			best_veh_cost = ret;

   180

			best_veh_index = i;

   181

		}

   182

	}

   183

   184

	return best_veh_index;

   185

}

   186

   187

static EngineID AiChooseAircraftToBuild(int32 money, byte flag)

   188

{

   189

	EngineID best_veh_index = INVALID_ENGINE;

   190

	int32 best_veh_cost = 0;

   191

	EngineID i;

   192

   193

	for (i = AIRCRAFT_ENGINES_INDEX; i != AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES; i++) {

   194

		const Engine* e = GetEngine(i);

   195

		int32 ret;

   196

   197

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

   198

			continue;

   199

		}

   200

   201

		if ((AircraftVehInfo(i)->subtype & AIR_CTOL) != flag) continue;

   202

   203

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

   204

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

   205

			best_veh_cost = ret;

   206

			best_veh_index = i;

   207

		}

   208

	}

   209

   210

	return best_veh_index;

   211

}

   212

   213

static int32 AiGetBasePrice(const Player* p)

   214

{

   215

	int32 base = _price.station_value;

   216

   217

	// adjust base price when more expensive vehicles are available

   218

	switch (p->ai.railtype_to_use) {

   219

		default: NOT_REACHED();

   220

		case RAILTYPE_RAIL:     break;

   221

		case RAILTYPE_ELECTRIC: break;

   222

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

   223

		case RAILTYPE_MAGLEV:   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(const Player* p, const 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(const Player* p, const Vehicle* v)

   244

{

   245

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

   246

	return AiChooseAircraftToBuild(

   247

		avail_money, AircraftVehInfo(v->engine_type)->subtype & AIR_CTOL

   248

	);

   249

}

   250

   251

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

   252

{

   253

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

   254

	const Vehicle* u = v;

   255

	int num = 0;

   256

   257

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

   258

		u = u->next;

   259

	}

   260

   261

	// XXX: check if a wagon

   262

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

   263

}

   264

   265

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

   266

{

   267

	error("!AiChooseShipToReplaceWith");

   268

   269

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

   270

	return INVALID_ENGINE;

   271

}

   272

   273

static void AiHandleGotoDepot(Player *p, int cmd)

   274

{

   275

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

   276

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

   277

   278

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

   279

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   280

		return;

   281

	}

   282

   283

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

   284

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

   285

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

   286

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

   287

	}

   288

}

   289

   290

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

   291

{

   292

	uint i;

   293

   294

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

   295

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

   296

			break;

   297

	}

   298

}

   299

   300

static void AiHandleReplaceTrain(Player *p)

   301

{

   302

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

   303

	BackuppedOrders orderbak[1];

   304

	EngineID veh;

   305

   306

	// wait until the vehicle reaches the depot.

   307

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

   308

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   309

		return;

   310

	}

   311

   312

	veh = AiChooseTrainToReplaceWith(p, v);

   313

	if (veh != INVALID_ENGINE) {

   314

		TileIndex tile;

   315

   316

		BackupVehicleOrders(v, orderbak);

   317

		tile = v->tile;

   318

   319

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

   320

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

   321

			VehicleID veh = _new_vehicle_id;

   322

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   323

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

   324

   325

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

   326

		}

   327

	}

   328

}

   329

   330

static void AiHandleReplaceRoadVeh(Player *p)

   331

{

   332

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

   333

	BackuppedOrders orderbak[1];

   334

	EngineID veh;

   335

   336

	if (!IsRoadVehInDepotStopped(v)) {

   337

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   338

		return;

   339

	}

   340

   341

	veh = AiChooseRoadVehToReplaceWith(p, v);

   342

	if (veh != INVALID_ENGINE) {

   343

		TileIndex tile;

   344

   345

		BackupVehicleOrders(v, orderbak);

   346

		tile = v->tile;

   347

   348

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

   349

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

   350

			VehicleID veh = _new_vehicle_id;

   351

   352

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   353

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

   354

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

   355

		}

   356

	}

   357

}

   358

   359

static void AiHandleReplaceAircraft(Player *p)

   360

{

   361

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

   362

	BackuppedOrders orderbak[1];

   363

	EngineID veh;

   364

   365

	if (!IsAircraftInHangarStopped(v)) {

   366

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   367

		return;

   368

	}

   369

   370

	veh = AiChooseAircraftToReplaceWith(p, v);

   371

	if (veh != INVALID_ENGINE) {

   372

		TileIndex tile;

   373

   374

		BackupVehicleOrders(v, orderbak);

   375

		tile = v->tile;

   376

   377

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

   378

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

   379

			VehicleID veh = _new_vehicle_id;

   380

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   381

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

   382

   383

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

   384

		}

   385

	}

   386

}

   387

   388

static void AiHandleReplaceShip(Player *p)

   389

{

   390

	error("!AiHandleReplaceShip");

   391

}

   392

   393

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

   394

   395

static CheckReplaceProc* const _veh_check_replace_proc[] = {

   396

	AiChooseTrainToReplaceWith,

   397

	AiChooseRoadVehToReplaceWith,

   398

	AiChooseShipToReplaceWith,

   399

	AiChooseAircraftToReplaceWith,

   400

};

   401

   402

typedef void DoReplaceProc(Player *p);

   403

static DoReplaceProc* const _veh_do_replace_proc[] = {

   404

	AiHandleReplaceTrain,

   405

	AiHandleReplaceRoadVeh,

   406

	AiHandleReplaceShip,

   407

	AiHandleReplaceAircraft

   408

};

   409

   410

static void AiStateCheckReplaceVehicle(Player *p)

   411

{

   412

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

   413

   414

	if (v->type == 0 ||

   415

			v->owner != _current_player ||

   416

			v->type > VEH_Ship ||

   417

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

   418

		p->ai.state = AIS_VEH_LOOP;

   419

	} else {

   420

		p->ai.state_counter = 0;

   421

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   422

	}

   423

}

   424

   425

static void AiStateDoReplaceVehicle(Player *p)

   426

{

   427

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

   428

   429

	p->ai.state = AIS_VEH_LOOP;

   430

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

   431

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

   432

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

   433

}

   434

   435

typedef struct FoundRoute {

   436

	int distance;

   437

	CargoID cargo;

   438

	void *from;

   439

	void *to;

   440

} FoundRoute;

   441

   442

static Town *AiFindRandomTown(void)

   443

{

   444

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

   445

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

   446

}

   447

   448

static Industry *AiFindRandomIndustry(void)

   449

{

   450

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

   451

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

   452

}

   453

   454

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   455

{

   456

	uint i;

   457

	CargoID cargo;

   458

	const Subsidy* s;

   459

	Industry* from;

   460

	TileIndex to_xy;

   461

   462

	// initially error

   463

	fr->distance = -1;

   464

   465

	// Randomize subsidy index..

   466

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

   467

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

   468

   469

	s = &_subsidies[i];

   470

   471

	// Don't want passengers or mail

   472

	cargo = s->cargo_type;

   473

	if (cargo == CT_INVALID ||

   474

			cargo == CT_PASSENGERS ||

   475

			cargo == CT_MAIL ||

   476

			s->age > 7) {

   477

		return;

   478

	}

   479

	fr->cargo = cargo;

   480

   481

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

   482

   483

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

   484

		Town* to_tow = GetTown(s->to);

   485

   486

		if (to_tow->population < (cargo == CT_FOOD ? 200U : 900U)) return; // error

   487

		fr->to = to_tow;

   488

		to_xy = to_tow->xy;

   489

	} else {

   490

		Industry* to_ind = GetIndustry(s->to);

   491

   492

		fr->to = to_ind;

   493

		to_xy = to_ind->xy;

   494

	}

   495

   496

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

   497

}

   498

   499

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   500

{

   501

	uint i;

   502

	const Subsidy* s;

   503

	Town *from,*to;

   504

   505

	// initially error

   506

	fr->distance = -1;

   507