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

    60

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    61

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

    62

}

    63

    64

    65

static void AiCase0(Player *p)

    66

{

    67

	p->ai.state = AIS_REMOVE_TRACK;

    68

	p->ai.state_counter = 0;

    69

}

    70

    71

static void AiCase1(Player *p)

    72

{

    73

	p->ai.cur_veh = NULL;

    74

	p->ai.state = AIS_VEH_LOOP;

    75

}

    76

    77

static void AiStateVehLoop(Player *p)

    78

{

    79

	Vehicle *v;

    80

	uint index;

    81

    82

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

    83

    84

	FOR_ALL_VEHICLES_FROM(v, index) {

    88

				v->type == VEH_Road ||

    89

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

    90

				v->type == VEH_Ship) {

    91

			/* replace engine? */

    92

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

    93

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

    94

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

    95

				p->ai.cur_veh = v;

    96

				return;

    97

			}

    98

    99

			/* not profitable? */

   100

			if (v->age >= 730 &&

   103

				p->ai.state_counter = 0;

   104

				p->ai.state = AIS_SELL_VEHICLE;

   105

				p->ai.cur_veh = v;

   106

				return;

   107

			}

   108

   109

			/* not reliable? */

   110

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

   111

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

   112

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

   113

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   114

				p->ai.cur_veh = v;

   115

				return;

   116

			}

   117

		}

   118

	}

   119

   120

	p->ai.state = AIS_WANT_NEW_ROUTE;

   121

	p->ai.state_counter = 0;

   122

}

   123

   124

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

   125

{

   126

	EngineID best_veh_index = INVALID_ENGINE;

   127

	byte best_veh_score = 0;

   128

	int32 ret;

   129

	EngineID i;

   130

   131

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

   132

		const RailVehicleInfo *rvi = RailVehInfo(i);

   133

		const Engine* e = GetEngine(i);

   134

   135

		if (e->railtype != railtype ||

   136

				rvi->flags & RVI_WAGON ||

   137

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

   138

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

   139

				e->reliability < 0x8A3D) {

   140

			continue;

   141

		}

   142

   143

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

   144

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

   145

				rvi->ai_rank >= best_veh_score) {

   146

			best_veh_score = rvi->ai_rank;

   147

			best_veh_index = i;

   148

		}

   149

	}

   150

   151

	return best_veh_index;

   152

}

   153

   154

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

   155

{

   156

	EngineID best_veh_index = INVALID_ENGINE;

   157

	int32 best_veh_cost = 0;

   158

	int32 ret;

   159

   160

	EngineID i = _cargoc.ai_roadveh_start[cargo];

   161

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

   162

	const Engine* e = GetEngine(i);

   163

   164

	do {

   165

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

   166

			continue;

   167

   168

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

   169

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

   170

			best_veh_cost = ret;

   171

			best_veh_index = i;

   172

		}

   173

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

   174

   175

	return best_veh_index;

   176

}

   177

   178

static EngineID AiChooseAircraftToBuild(int32 money, byte flag)

   179

{

   180

	EngineID best_veh_index = INVALID_ENGINE;

   181

	int32 best_veh_cost = 0;

   182

	int32 ret;

   183

   184

	EngineID i = AIRCRAFT_ENGINES_INDEX;

   185

	EngineID end = i + NUM_AIRCRAFT_ENGINES;

   186

	const Engine* e = GetEngine(i);

   187

   188

	do {

   189

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

   190

			continue;

   191

   192

		if (flag&1) {

   193

			if (i<253) continue;

   194

		} else {

   195

			if (i>=253) continue;

   196

		}

   197

   198

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

   199

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

   200

			best_veh_cost = ret;

   201

			best_veh_index = i;

   202

		}

   203

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

   204

   205

	return best_veh_index;

   206

}

   207

   208

static int32 AiGetBasePrice(Player *p)

   209

{

   210

	int32 base = _price.station_value;

   211

   212

	// adjust base price when more expensive vehicles are available

   217

   218

	return base;

   219

}

   220

   221

#if 0

   222

static EngineID AiChooseShipToBuild(byte cargo, int32 money)

   223

{

   224

	// XXX: not done

   225

	return INVALID_ENGINE;

   226

}

   227

#endif

   228

   229

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

   230

{

   231

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

   232

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

   233

}

   234

   235

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

   236

{

   237

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

   238

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

   239

}

   240

   241

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

   242

{

   243

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

   244

	int num=0;

   245

	Vehicle *u = v;

   246

   247

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

   248

		u = u->next;

   249

	}

   250

   251

	// XXX: check if a wagon

   252

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

   253

}

   254

   255

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

   256

{

   257

	error("!AiChooseShipToReplaceWith");

   258

   259

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

   260

	return INVALID_ENGINE;

   261

}

   262

   263

static void AiHandleGotoDepot(Player *p, int cmd)

   264

{

   265

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

   266

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

   267

   268

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

   269

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   270

		return;

   271

	}

   272

   273

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

   274

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

   275

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

   276

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

   277

	}

   278

}

   279

   280

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

   281

{

   282

	uint i;

   283

   284

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

   285

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

   286

			break;

   287

	}

   288

}

   289

   290

static void AiHandleReplaceTrain(Player *p)

   291

{

   292

	Vehicle *v = p->ai.cur_veh;

   293

	BackuppedOrders orderbak[1];

   294

	EngineID veh;

   295

   296

	// wait until the vehicle reaches the depot.

   297

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

   298

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   299

		return;

   300

	}

   301

   302

	veh = AiChooseTrainToReplaceWith(p, v);

   303

	if (veh != INVALID_ENGINE) {

   304

		TileIndex tile;

   305

   306

		BackupVehicleOrders(v, orderbak);

   307

		tile = v->tile;

   308

   309

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

   310

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

   311

			VehicleID veh = _new_train_id;

   312

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   313

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

   314

   315

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

   316

		}

   317

	}

   318

}

   319

   320

static void AiHandleReplaceRoadVeh(Player *p)

   321

{

   322

	Vehicle *v = p->ai.cur_veh;

   323

	BackuppedOrders orderbak[1];

   324

	EngineID veh;

   325

   326

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

   327

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   328

		return;

   329

	}

   330

   331

	veh = AiChooseRoadVehToReplaceWith(p, v);

   332

	if (veh != INVALID_ENGINE) {

   333

		TileIndex tile;

   334

   335

		BackupVehicleOrders(v, orderbak);

   336

		tile = v->tile;

   337

   338

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

   339

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

   340

			VehicleID veh = _new_roadveh_id;

   341

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   342

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

   343

   344

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

   345

		}

   346

	}

   347

}

   348

   349

static void AiHandleReplaceAircraft(Player *p)

   350

{

   351

	Vehicle *v = p->ai.cur_veh;

   352

	BackuppedOrders orderbak[1];

   353

	EngineID veh;

   354

   355

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

   356

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   357

		return;

   358

	}

   359

   360

	veh = AiChooseAircraftToReplaceWith(p, v);

   361

	if (veh != INVALID_ENGINE) {

   362

		TileIndex tile;

   363

   364

		BackupVehicleOrders(v, orderbak);

   365

		tile = v->tile;

   366

   367

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

   368

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

   369

			VehicleID veh = _new_aircraft_id;

   370

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   371

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

   372

   373

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

   374

		}

   375

	}

   376

}

   377

   378

static void AiHandleReplaceShip(Player *p)

   379

{

   380

	error("!AiHandleReplaceShip");

   381

}

   382

   383

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

   384

   386

	AiChooseTrainToReplaceWith,

   387

	AiChooseRoadVehToReplaceWith,

   388

	AiChooseShipToReplaceWith,

   389

	AiChooseAircraftToReplaceWith,

   390

};

   391

   392

typedef void DoReplaceProc(Player *p);

   394

	AiHandleReplaceTrain,

   395

	AiHandleReplaceRoadVeh,

   396

	AiHandleReplaceShip,

   397

	AiHandleReplaceAircraft

   398

};

   399

   400

static void AiStateCheckReplaceVehicle(Player *p)

   401

{

   402

	Vehicle *v = p->ai.cur_veh;

   403

   404

	if (v->type == 0 ||

   405

			v->owner != _current_player ||

   406

			v->type > VEH_Ship ||

   407

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

   408

		p->ai.state = AIS_VEH_LOOP;

   409

	} else {

   410

		p->ai.state_counter = 0;

   411

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   412

	}

   413

}

   414

   415

static void AiStateDoReplaceVehicle(Player *p)

   416

{

   419

	p->ai.state = AIS_VEH_LOOP;

   420

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

   422

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

   423

}

   424

   425

typedef struct FoundRoute {

   426

	int distance;

   427

	byte cargo;

   428

	void *from;

   429

	void *to;

   430

} FoundRoute;

   431

   432

static Town *AiFindRandomTown(void)

   433

{

   434

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

   435

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

   436

}

   437

   438

static Industry *AiFindRandomIndustry(void)

   439

{

   440

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

   441

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

   442

}

   443

   444

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   445

{

   446

	uint i;

   447

	byte cargo;

   448

	Subsidy *s;

   449

	Industry *from, *to_ind;

   450

	Town *to_tow;

   451

	TileIndex to_xy;

   452

   453

	// initially error

   454

	fr->distance = -1;

   455

   456

	// Randomize subsidy index..

   457

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

   459

   460

	s = &_subsidies[i];

   461

   462

	// Don't want passengers or mail

   463

	cargo = s->cargo_type;

   464

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

   465

		return;

   466

	fr->cargo = cargo;

   467

   468

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

   469

   470

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

   471

		to_tow = GetTown(s->to);

   472

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

   473

			return; // error

   474

		fr->to = to_tow;

   475

		to_xy = to_tow->xy;

   476

	} else {

   477

		to_ind = GetIndustry(s->to);

   478

		fr->to = to_ind;

   479

		to_xy = to_ind->xy;

   480

	}

   481

   482

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

   483

}

   484

   485

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   486

{

   487

	uint i;

   488

	Subsidy *s;

   489

	Town *from,*to;

   490

   491

	// initially error

   492

	fr->distance = -1;

   493

   494

	// Randomize subsidy index..

   495

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

   497

   498

	s = &_subsidies[i];

   499

   500

	// Only want passengers

   502

	fr->cargo = s->cargo_type;

   503

   504

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

   505

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

   506

   507

	// They must be big enough