1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "player.h"

     4

#include "vehicle.h"

     5

#include "engine.h"

     6

#include "command.h"

     7

#include "town.h"

     8

#include "industry.h"

     9

#include "station.h"

    10

#include "pathfind.h"

    11

#include "economy.h"

    12

#include "airport.h"

    13

    14

// remove some day perhaps?

    15

static Player *_cur_ai_player;

    16

static uint _ai_service_interval;

    17

    18

typedef void AiStateAction(Player *p);

    19

    20

enum {

    21

	AIS_0 = 0,

    22

	AIS_1 = 1,

    23

	AIS_VEH_LOOP = 2,

    24

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    25

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    26

	AIS_WANT_NEW_ROUTE = 5,

    27

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    28

	AIS_BUILD_RAIL = 7,

    29

	AIS_BUILD_RAIL_VEH = 8,

    30

	AIS_DELETE_RAIL_BLOCKS = 9,

    31

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    32

	AIS_BUILD_ROAD = 11,

    33

	AIS_BUILD_ROAD_VEHICLES = 12,

    34

	AIS_DELETE_ROAD_BLOCKS = 13,

    35

	AIS_AIRPORT_STUFF = 14,

    36

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    37

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    38

	AIS_CHECK_SHIP_STUFF = 17,

    39

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    40

	AIS_DO_SHIP_STUFF = 19,

    41

	AIS_SELL_VEHICLE = 20,

    42

	AIS_REMOVE_STATION = 21,

    43

	AIS_REMOVE_TRACK = 22,

    44

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    45

};

    46

    47

    48

#include "table/ai_rail.h"

    49

    50

static byte GetRailTrackStatus(TileIndex tile) {

    51

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

    52

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

    53

}

    54

    55

    56

static void AiCase0(Player *p)

    57

{

    58

	p->ai.state = AIS_REMOVE_TRACK;

    59

	p->ai.state_counter = 0;

    60

}

    61

    62

static void AiCase1(Player *p)

    63

{

    64

	p->ai.cur_veh = NULL;

    65

	p->ai.state = AIS_VEH_LOOP;

    66

}

    67

    68

static void AiStateVehLoop(Player *p)

    69

{

    70

	Vehicle *v;

    71

    72

	v = p->ai.cur_veh == NULL ? _vehicles : p->ai.cur_veh+1;

    73

    74

	for (;v != endof(_vehicles); v++) {

    75

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

    76

			continue;

    77

    78

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

    79

				v->type == VEH_Road ||

    80

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

    81

				v->type == VEH_Ship) {

    82

    83

			/* replace engine? */

    84

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

    85

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

    86

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

    87

				p->ai.cur_veh = v;

    88

				return;

    89

			}

    90

    91

			/* not profitable? */

    92

			if (v->age >= 730 &&

    93

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

    94

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

    95

				p->ai.state_counter = 0;

    96

				p->ai.state = AIS_SELL_VEHICLE;

    97

				p->ai.cur_veh = v;

    98

				return;

    99

			}

   100

   101

			/* not reliable? */

   102

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

   103

					_engines[v->engine_type].reliability < 35389) ||

   104

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

   105

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   106

				p->ai.cur_veh = v;

   107

				return;

   108

			}

   109

		}

   110

	}

   111

   112

	p->ai.state = AIS_WANT_NEW_ROUTE;

   113

	p->ai.state_counter = 0;

   114

}

   115

   116

static int AiChooseTrainToBuild(byte railtype, int32 money, byte flag)

   117

{

   118

	int best_veh_index = -1;

   119

	byte best_veh_score = 0;

   120

	int32 r;

   121

	int i;

   122

   123

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

   124

		RailVehicleInfo *rvi = &rail_vehinfo(i);

   125

		Engine *e = DEREF_ENGINE(i);

   126

   127

		if (e->railtype != railtype || rvi->flags & RVI_WAGON

   128

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

   129

			continue;

   130

   131

		r = DoCommandByTile(0, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);

   132

		if (r != CMD_ERROR &&

   133

					(!(_cmd_build_rail_veh_var1&1) || !(flag&1)) &&

   134

					r <= money &&

   135

				_cmd_build_rail_veh_score >= best_veh_score) {

   136

			best_veh_score = _cmd_build_rail_veh_score;

   137

			best_veh_index = i;

   138

		}

   139

	}

   140

   141

	return best_veh_index;

   142

}

   143

   144

static int AiChooseRoadVehToBuild(byte cargo, int32 money)

   145

{

   146

	int best_veh_index = -1;

   147

	int32 best_veh_cost = 0;

   148

	int32 r;

   149

   150

	int i = _cargoc.ai_roadveh_start[cargo];

   151

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

   152

	Engine *e = &_engines[i];

   153

	do {

   154

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

   155

			continue;

   156

   157

		r = DoCommandByTile(0, i, 0, 0, CMD_BUILD_ROAD_VEH);

   158

		if (r != CMD_ERROR && r <= money && r >= best_veh_cost) {

   159

			best_veh_cost = r;

   160

			best_veh_index = i;

   161

		}

   162

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

   163

   164

	return best_veh_index;

   165

}

   166

   167

static int AiChooseAircraftToBuild(int32 money, byte flag)

   168

{

   169

	int best_veh_index = -1;

   170

	int32 best_veh_cost = 0;

   171

	int32 r;

   172

   173

	int i = AIRCRAFT_ENGINES_INDEX;

   174

	int end = i + NUM_AIRCRAFT_ENGINES;

   175

	Engine *e = &_engines[i];

   176

	do {

   177

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

   178

			continue;

   179

   180

		if (flag&1) {

   181

			if (i<253) continue;

   182

		} else {

   183

			if (i>=253) continue;

   184

		}

   185

   186

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

   187

		if (r != CMD_ERROR && r <= money && r >= best_veh_cost) {

   188

			best_veh_cost = r;

   189

			best_veh_index = i;

   190

		}

   191

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

   192

   193

	return best_veh_index;

   194

}

   195

   196

static int32 AiGetBasePrice(Player *p)

   197

{

   198

	int32 base = _price.station_value;

   199

   200

	// adjust base price when more expensive vehicles are available

   201

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

   202

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

   203

   204

	return base;

   205

}

   206

   207

#if 0

   208

static int AiChooseShipToBuild(byte cargo, int32 money)

   209

{

   210

	// XXX: not done

   211

	return 0;

   212

}

   213

#endif

   214

   215

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

   216

{

   217

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

   218

	return AiChooseRoadVehToBuild(v->cargo_type, avail_money);

   219

}

   220

   221

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

   222

{

   223

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

   224

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

   225

}

   226

   227

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

   228

{

   229

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

   230

	int num=0;

   231

	Vehicle *u = v;

   232

   233

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

   234

		u = u->next;

   235

	}

   236

   237

	// XXX: check if a wagon

   238

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

   239

}

   240

   241

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

   242

{

   243

	error("!AiChooseShipToReplaceWith");

   244

   245

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

   246

	return 0;

   247

}

   248

   249

static void AiHandleGotoDepot(Player *p, int cmd)

   250

{

   251

	if ((p->ai.cur_veh->next_order & OT_MASK) != OT_GOTO_DEPOT)

   252

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

   253

   254

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

   255

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   256

		return;

   257

	}

   258

   259

	if ((p->ai.cur_veh->next_order&OT_MASK) == OT_GOTO_DEPOT) {

   260

		p->ai.cur_veh->next_order = OT_DUMMY;

   261

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

   262

	}

   263

}

   264

   265

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

   266

{

   267

	uint16 *os = bak->order, ord;

   268

	int ind = 0;

   269

	while ((ord = *os++) != 0) {

   270

		if (DoCommandByTile(0, v->index + (ind << 16), ord, DC_EXEC, CMD_INSERT_ORDER) == CMD_ERROR)

   271

			break;

   272

		ind++;

   273

	}

   274

}

   275

   276

static void AiHandleReplaceTrain(Player *p)

   277

{

   278

	Vehicle *v = p->ai.cur_veh;

   279

	BackuppedOrders orderbak[1];

   280

	int veh;

   281

	uint tile;

   282

   283

	// wait until the vehicle reaches the depot.

   284

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

   285

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   286

		return;

   287

	}

   288

   289

	veh = AiChooseTrainToReplaceWith(p, v);

   290

	if (veh != -1) {

   291

		BackupVehicleOrders(v, orderbak);

   292

		tile = v->tile;

   293

   294

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

   295

			 DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE) != CMD_ERROR) {

   296

			veh = _new_train_id;

   297

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   298

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

   299

   300

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

   301

		}

   302

	}

   303

}

   304

   305

static void AiHandleReplaceRoadVeh(Player *p)

   306

{

   307

	Vehicle *v = p->ai.cur_veh;

   308

	BackuppedOrders orderbak[1];

   309

	int veh;

   310

	uint tile;

   311

   312

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

   313

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   314

		return;

   315

	}

   316

   317

	veh = AiChooseRoadVehToReplaceWith(p, v);

   318

	if (veh != -1) {

   319

		BackupVehicleOrders(v, orderbak);

   320

		tile = v->tile;

   321

   322

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

   323

			 DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH) != CMD_ERROR) {

   324

			veh = _new_roadveh_id;

   325

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   326

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

   327

   328

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

   329

		}

   330

	}

   331

}

   332

   333

static void AiHandleReplaceAircraft(Player *p)

   334

{

   335

	Vehicle *v = p->ai.cur_veh;

   336

	int veh;

   337

	BackuppedOrders orderbak[1];

   338

	uint tile;

   339

   340

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

   341

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   342

		return;

   343

	}

   344

   345

	veh = AiChooseAircraftToReplaceWith(p, v);

   346

	if (veh != -1) {

   347

		BackupVehicleOrders(v, orderbak);

   348

		tile = v->tile;

   349

   350

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

   351

			 DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT) != CMD_ERROR) {

   352

			veh = _new_aircraft_id;

   353

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   354

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

   355

   356

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

   357

		}

   358

	}

   359

}

   360

   361

static void AiHandleReplaceShip(Player *p)

   362

{

   363

	error("!AiHandleReplaceShip");

   364

}

   365

   366

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

   367

   368

static CheckReplaceProc * const _veh_check_replace_proc[] = {

   369

	AiChooseTrainToReplaceWith,

   370

	AiChooseRoadVehToReplaceWith,

   371

	AiChooseShipToReplaceWith,

   372

	AiChooseAircraftToReplaceWith,

   373

};

   374

   375

typedef void DoReplaceProc(Player *p);

   376

static DoReplaceProc * const _veh_do_replace_proc[] = {

   377

	AiHandleReplaceTrain,

   378

	AiHandleReplaceRoadVeh,

   379

	AiHandleReplaceShip,

   380

	AiHandleReplaceAircraft

   381

};

   382

   383

static void AiStateCheckReplaceVehicle(Player *p)

   384

{

   385

	Vehicle *v = p->ai.cur_veh;

   386

   387

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

   388

		p->ai.state = AIS_VEH_LOOP;

   389

	} else {

   390

		p->ai.state_counter = 0;

   391

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   392

	}

   393

}

   394

   395

static void AiStateDoReplaceVehicle(Player *p)

   396

{

   397

	Vehicle *v = p->ai.cur_veh;

   398

	p->ai.state = AIS_VEH_LOOP;

   399

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

   400

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

   401

		return;

   402

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

   403

}

   404

   405

typedef struct FoundRoute {

   406

	int distance;

   407

	byte cargo;

   408

	void *from;

   409

	void *to;

   410

} FoundRoute;

   411

   412

static Town *AiFindRandomTown() {

   413

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

   414

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

   415

}

   416

   417

static Industry *AiFindRandomIndustry() {

   418

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

   419

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

   420

}

   421

   422

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   423

{

   424

	int i;

   425

	byte cargo;

   426

	Subsidy *s;

   427

	Industry *from, *to_ind;

   428

	Town *to_tow;

   429

	TileIndex to_xy;

   430

   431

	// initially error

   432

	fr->distance = -1;

   433

   434

	// Randomize subsidy index..

   435

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

   436

	if (i >= lengthof(_subsidies))

   437

		return;

   438

   439

	s = &_subsidies[i];

   440

   441

	// Don't want passengers or mail

   442

	cargo = s->cargo_type;

   443

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

   444

		return;

   445

	fr->cargo = cargo;

   446

   447

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

   448

   449

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

   450

		to_tow = DEREF_TOWN(s->to);

   451

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

   452

			return; // error

   453

		fr->to = to_tow;

   454

		to_xy = to_tow->xy;

   455

	} else {

   456

		to_ind = DEREF_INDUSTRY(s->to);

   457

		fr->to = to_ind;

   458

		to_xy = to_ind->xy;

   459

	}

   460

   461

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

   462

}

   463

   464

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   465

{

   466

	uint i;

   467

	Subsidy *s;

   468

	Town *from,*to;

   469

   470

	// initially error

   471

	fr->distance = -1;

   472

   473

	// Randomize subsidy index..

   474

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

   475

	if (i >= lengthof(_subsidies))

   476

		return;

   477

   478

	s = &_subsidies[i];

   479

   480

	// Only want passengers

   481

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

   482

		return;

   483

	fr->cargo = s->cargo_type;

   484

   485

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

   486

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

   487

   488

	// They must be big enough

   489

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

   490

		return;

   491

   492

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

   493

}

   494

   495

static void AiFindRandomIndustryRoute(FoundRoute *fr)

   496

{

   497

	Industry *i,*i2;

   498

	Town *t;

   499

	uint32 r;

   500

	byte cargo;

   501

   502

	// initially error

   503

	fr->distance = -1;

   504

   505

	r = Random();

   506

   507

	// pick a source

   508

	fr->from = i = AiFindRandomIndustry();

   509

	if (i == NULL)

   510

		return;

   511

   512

	// pick a random produced cargo

   513

	cargo = i->produced_cargo[0];

   514

	if (r&1 && i->produced_cargo[1] != 0xFF)

   515

		cargo = i->produced_cargo[1];

   516

   517

	fr->cargo = cargo;

   518

   519

	// don't allow passengers

   520

	if (cargo == 0xFF || cargo == CT_PASSENGERS)

   521

		return;

   522

   523

	if (cargo != CT_GOODS && cargo != CT_FOOD) {

   524

		// pick a dest, and see if it can receive

   525

		i2 = AiFindRandomIndustry();