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

    21

// remove some day perhaps?

    22

static Player *_cur_ai_player;

    23

static uint _ai_service_interval;

    24

    25

typedef void AiStateAction(Player *p);

    26

    27

enum {

    28

	AIS_0 = 0,

    29

	AIS_1 = 1,

    30

	AIS_VEH_LOOP = 2,

    31

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    32

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    33

	AIS_WANT_NEW_ROUTE = 5,

    34

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    35

	AIS_BUILD_RAIL = 7,

    36

	AIS_BUILD_RAIL_VEH = 8,

    37

	AIS_DELETE_RAIL_BLOCKS = 9,

    38

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    39

	AIS_BUILD_ROAD = 11,

    40

	AIS_BUILD_ROAD_VEHICLES = 12,

    41

	AIS_DELETE_ROAD_BLOCKS = 13,

    42

	AIS_AIRPORT_STUFF = 14,

    43

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    44

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    45

	AIS_CHECK_SHIP_STUFF = 17,

    46

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    47

	AIS_DO_SHIP_STUFF = 19,

    48

	AIS_SELL_VEHICLE = 20,

    49

	AIS_REMOVE_STATION = 21,

    50

	AIS_REMOVE_TRACK = 22,

    51

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    52

};

    53

    54

    55

#include "table/ai_rail.h"

    56

    57

static byte GetRailTrackStatus(TileIndex tile) {

    58

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    59

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

    60

}

    61

    62

    63

static void AiCase0(Player *p)

    64

{

    65

	p->ai.state = AIS_REMOVE_TRACK;

    66

	p->ai.state_counter = 0;

    67

}

    68

    69

static void AiCase1(Player *p)

    70

{

    71

	p->ai.cur_veh = NULL;

    72

	p->ai.state = AIS_VEH_LOOP;

    73

}

    74

    75

static void AiStateVehLoop(Player *p)

    76

{

    77

	Vehicle *v;

    78

	uint index;

    79

    80

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

    81

    82

	FOR_ALL_VEHICLES_FROM(v, index) {

    83

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

    84

			continue;

    85

    86

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

    87

				v->type == VEH_Road ||

    88

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

    89

				v->type == VEH_Ship) {

    90

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

   101

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

   102

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

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

   125

{

   126

	int best_veh_index = -1;

   127

	byte best_veh_score = 0;

   128

	int32 ret;

   129

	int 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 || rvi->flags & RVI_WAGON

   136

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

   137

			continue;

   138

   139

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

   140

		if (!CmdFailed(ret) && (!(_cmd_build_rail_veh_var1&1) || !(flag&1)) && ret <= money &&

   141

				_cmd_build_rail_veh_score >= best_veh_score) {

   142

			best_veh_score = _cmd_build_rail_veh_score;

   143

			best_veh_index = i;

   144

		}

   145

	}

   146

   147

	return best_veh_index;

   148

}

   149

   150

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

   151

{

   152

	int best_veh_index = -1;

   153

	int32 best_veh_cost = 0;

   154

	int32 ret;

   155

   156

	int i = _cargoc.ai_roadveh_start[cargo];

   157

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

   158

	const Engine* e = GetEngine(i);

   159

   160

	do {

   161

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

   162

			continue;

   163

   164

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

   165

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

   166

			best_veh_cost = ret;

   167

			best_veh_index = i;

   168

		}

   169

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

   170

   171

	return best_veh_index;

   172

}

   173

   174

static int AiChooseAircraftToBuild(int32 money, byte flag)

   175

{

   176

	int best_veh_index = -1;

   177

	int32 best_veh_cost = 0;

   178

	int32 ret;

   179

   180

	int i = AIRCRAFT_ENGINES_INDEX;

   181

	int end = i + NUM_AIRCRAFT_ENGINES;

   182

	const Engine* e = GetEngine(i);

   183

   184

	do {

   185

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

   186

			continue;

   187

   188

		if (flag&1) {

   189

			if (i<253) continue;

   190

		} else {

   191

			if (i>=253) continue;

   192

		}

   193

   194

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

   195

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

   196

			best_veh_cost = ret;

   197

			best_veh_index = i;

   198

		}

   199

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

   200

   201

	return best_veh_index;

   202

}

   203

   204

static int32 AiGetBasePrice(Player *p)

   205

{

   206

	int32 base = _price.station_value;

   207

   208

	// adjust base price when more expensive vehicles are available

   209

	if (p->ai.railtype_to_use == 1) base = (base * 3) >> 1;

   210

	else if (p->ai.railtype_to_use == 2) base *= 2;

   211

   212

	return base;

   213

}

   214

   215

#if 0

   216

static int AiChooseShipToBuild(byte cargo, int32 money)

   217

{

   218

	// XXX: not done

   219

	return 0;

   220

}

   221

#endif

   222

   223

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

   224

{

   225

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

   226

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

   227

}

   228

   229

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

   230

{

   231

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

   232

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

   233

}

   234

   235

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

   236

{

   237

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

   238

	int num=0;

   239

	Vehicle *u = v;

   240

   241

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

   242

		u = u->next;

   243

	}

   244

   245

	// XXX: check if a wagon

   246

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

   247

}

   248

   249

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

   250

{

   251

	error("!AiChooseShipToReplaceWith");

   252

   253

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

   254

	return 0;

   255

}

   256

   257

static void AiHandleGotoDepot(Player *p, int cmd)

   258

{

   259

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

   260

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

   261

   262

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

   263

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   264

		return;

   265

	}

   266

   267

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

   268

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

   269

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

   270

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

   271

	}

   272

}

   273

   274

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

   275

{

   276

	int i;

   277

   278

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

   279

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

   280

			break;

   281

}

   282

   283

static void AiHandleReplaceTrain(Player *p)

   284

{

   285

	Vehicle *v = p->ai.cur_veh;

   286

	BackuppedOrders orderbak[1];

   287

	int veh;

   288

   289

	// wait until the vehicle reaches the depot.

   290

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

   291

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   292

		return;

   293

	}

   294

   295

	veh = AiChooseTrainToReplaceWith(p, v);

   296

	if (veh != -1) {

   297

		TileIndex tile;

   298

   299

		BackupVehicleOrders(v, orderbak);

   300

		tile = v->tile;

   301

   302

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

   303

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

   304

			veh = _new_train_id;

   305

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   306

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

   307

   308

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

   309

		}

   310

	}

   311

}

   312

   313

static void AiHandleReplaceRoadVeh(Player *p)

   314

{

   315

	Vehicle *v = p->ai.cur_veh;

   316

	BackuppedOrders orderbak[1];

   317

	int veh;

   318

   319

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

   320

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   321

		return;

   322

	}

   323

   324

	veh = AiChooseRoadVehToReplaceWith(p, v);

   325

	if (veh != -1) {

   326

		TileIndex tile;

   327

   328

		BackupVehicleOrders(v, orderbak);

   329

		tile = v->tile;

   330

   331

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

   332

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

   333

			veh = _new_roadveh_id;

   334

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   335

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

   336

   337

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

   338

		}

   339

	}

   340

}

   341

   342

static void AiHandleReplaceAircraft(Player *p)

   343

{

   344

	Vehicle *v = p->ai.cur_veh;

   345

	int veh;

   346

	BackuppedOrders orderbak[1];

   347

   348

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

   349

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   350

		return;

   351

	}

   352

   353

	veh = AiChooseAircraftToReplaceWith(p, v);

   354

	if (veh != -1) {

   355

		TileIndex tile;

   356

   357

		BackupVehicleOrders(v, orderbak);

   358

		tile = v->tile;

   359

   360

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

   361

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

   362

			veh = _new_aircraft_id;

   363

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

   364

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

   365

   366

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

   367

		}

   368

	}

   369

}

   370

   371

static void AiHandleReplaceShip(Player *p)

   372

{

   373

	error("!AiHandleReplaceShip");

   374

}

   375

   376

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

   377

   378

static CheckReplaceProc * const _veh_check_replace_proc[] = {

   379

	AiChooseTrainToReplaceWith,

   380

	AiChooseRoadVehToReplaceWith,

   381

	AiChooseShipToReplaceWith,

   382

	AiChooseAircraftToReplaceWith,

   383

};

   384

   385

typedef void DoReplaceProc(Player *p);

   386

static DoReplaceProc * const _veh_do_replace_proc[] = {

   387

	AiHandleReplaceTrain,

   388

	AiHandleReplaceRoadVeh,

   389

	AiHandleReplaceShip,

   390

	AiHandleReplaceAircraft

   391

};

   392

   393

static void AiStateCheckReplaceVehicle(Player *p)

   394

{

   395

	Vehicle *v = p->ai.cur_veh;

   396

   397

	if (v->type == 0 || v->owner != _current_player || v->type > VEH_Ship || _veh_check_replace_proc[v->type - VEH_Train](p, v) == -1) {

   398

		p->ai.state = AIS_VEH_LOOP;

   399

	} else {

   400

		p->ai.state_counter = 0;

   401

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   402

	}

   403

}

   404

   405

static void AiStateDoReplaceVehicle(Player *p)

   406

{

   407

	Vehicle *v = p->ai.cur_veh;

   408

	p->ai.state = AIS_VEH_LOOP;

   409

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

   410

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

   411

		return;

   412

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

   413

}

   414

   415

typedef struct FoundRoute {

   416

	int distance;

   417

	byte cargo;

   418

	void *from;

   419

	void *to;

   420

} FoundRoute;

   421

   422

static Town *AiFindRandomTown(void)

   423

{

   424

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

   425

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

   426

}

   427

   428

static Industry *AiFindRandomIndustry(void)

   429

{

   430

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

   431

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

   432

}

   433

   434

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   435

{

   436

	uint i;

   437

	byte cargo;

   438

	Subsidy *s;

   439

	Industry *from, *to_ind;

   440

	Town *to_tow;

   441

	TileIndex to_xy;

   442

   443

	// initially error

   444

	fr->distance = -1;

   445

   446

	// Randomize subsidy index..

   447

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

   448

	if (i >= lengthof(_subsidies))

   449

		return;

   450

   451

	s = &_subsidies[i];

   452

   453

	// Don't want passengers or mail

   454

	cargo = s->cargo_type;

   455

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

   456

		return;

   457

	fr->cargo = cargo;

   458

   459

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

   460

   461

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

   462

		to_tow = GetTown(s->to);

   463

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

   464

			return; // error

   465

		fr->to = to_tow;

   466

		to_xy = to_tow->xy;

   467

	} else {

   468

		to_ind = GetIndustry(s->to);

   469

		fr->to = to_ind;

   470

		to_xy = to_ind->xy;

   471

	}

   472

   473

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

   474

}

   475

   476

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   477

{

   478

	uint i;

   479

	Subsidy *s;

   480

	Town *from,*to;

   481

   482

	// initially error

   483

	fr->distance = -1;

   484

   485

	// Randomize subsidy index..

   486

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

   487

	if (i >= lengthof(_subsidies))

   488

		return;

   489

   490

	s = &_subsidies[i];

   491

   492

	// Only want passengers

   493

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

   494

		return;

   495

	fr->cargo = s->cargo_type;

   496

   497

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

   498

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

   499

   500

	// They must be big enough

   501

	if (from->population < 400 || to->population < 400)

   502

		return;

   503

   504

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

   505

}

   506

   507

static void AiFindRandomIndustryRoute(FoundRoute *fr)

   508

{

   509

	Industry *i,*i2;

   510

	Town *t;

   511

	uint32 r;

   512

	byte cargo;

   513

   514

	// initially error

   515

	fr->distance = -1;

   516