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

    17

typedef void AiStateAction(Player *p);

    18

    19

enum {

    20

	AIS_0 = 0,

    21

	AIS_1 = 1,

    22

	AIS_VEH_LOOP = 2,

    23

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

    24

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

    25

	AIS_WANT_NEW_ROUTE = 5,

    26

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

    27

	AIS_BUILD_RAIL = 7,

    28

	AIS_BUILD_RAIL_VEH = 8,

    29

	AIS_DELETE_RAIL_BLOCKS = 9,

    30

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

    31

	AIS_BUILD_ROAD = 11,

    32

	AIS_BUILD_ROAD_VEHICLES = 12,

    33

	AIS_DELETE_ROAD_BLOCKS = 13,

    34

	AIS_AIRPORT_STUFF = 14,

    35

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

    36

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

    37

	AIS_CHECK_SHIP_STUFF = 17,

    38

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

    39

	AIS_DO_SHIP_STUFF = 19,

    40

	AIS_SELL_VEHICLE = 20,

    41

	AIS_REMOVE_STATION = 21,

    42

	AIS_REMOVE_TRACK = 22,

    43

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

    44

};

    45

    46

    47

#include "table/ai_rail.h"

    48

    49

static byte GetRailTrackStatus(TileIndex tile) {

    51

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

    52

}

    53

    54

    55

static void AiCase0(Player *p)

    56

{

    57

	p->ai.state = AIS_REMOVE_TRACK;

    58

	p->ai.state_counter = 0;

    59

}

    60

    61

static void AiCase1(Player *p)

    62

{

    63

	p->ai.cur_veh = NULL;

    64

	p->ai.state = AIS_VEH_LOOP;

    65

}

    66

    67

static void AiStateVehLoop(Player *p)

    68

{

    69

	Vehicle *v;

    70

    71

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

    72

    73

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

    74

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

    75

			continue;

    76

    77

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

    78

				v->type == VEH_Road ||

    79

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

    80

				v->type == VEH_Ship) {

    81

    82

			/* replace engine? */

    83

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

    84

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

    85

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

    86

				p->ai.cur_veh = v;

    87

				return;

    88

			}

    89

    90

			/* not profitable? */

    91

			if (v->age >= 730 &&

    92

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

    93

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

    94

				p->ai.state_counter = 0;

    95

				p->ai.state = AIS_SELL_VEHICLE;

    96

				p->ai.cur_veh = v;

    97

				return;

    98

			}

    99

   100

			/* not reliable? */

   101

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

   102

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

   103

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

   104

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

   105

				p->ai.cur_veh = v;

   106

				return;

   107

			}

   108

		}

   109

	}

   110

   111

	p->ai.state = AIS_WANT_NEW_ROUTE;

   112

	p->ai.state_counter = 0;

   113

}

   114

   115

// XXX

   116

static const byte _rail_locos_count[3] = {

   117

	27, 3, 5		

   118

};

   119

extern const byte _rail_engines_start[3];

   120

   121

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

   122

{

   123

	int best_veh_index = -1;

   124

	byte best_veh_score = 0;

   125

	int32 r;

   126

   127

	int i = _rail_engines_start[railtype];

   128

	int end = i + _rail_locos_count[railtype];

   129

	Engine *e = &_engines[i];

   130

	do {

   131

		assert(!(_rail_vehicle_info[i].flags & RVI_WAGON));

   132

   133

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

   134

			continue;

   135

   136

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

   137

		if (r != CMD_ERROR && 

   138

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

   139

					r <= money && 

   140

				_cmd_build_rail_veh_score >= best_veh_score) {

   141

			best_veh_score = _cmd_build_rail_veh_score;

   142

			best_veh_index = i;

   143

		}

   144

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

   145

   146

	return best_veh_index;

   147

}

   148

   149

static int AiChooseRoadVehToBuild(byte cargo, int32 money)

   150

{

   151

	int best_veh_index = -1;

   152

	int32 best_veh_cost = 0;

   153

	int32 r;

   154

   155

	int i = _cargoc.ai_roadveh_start[cargo];

   156

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

   157

	Engine *e = &_engines[i];

   158

	do {

   159

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

   160

			continue;

   161

   162

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

   163

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

   164

			best_veh_cost = r;

   165

			best_veh_index = i;

   166

		}

   167

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

   168

   169

	return best_veh_index;

   170

}

   171

   172

static int AiChooseAircraftToBuild(int32 money, byte flag)

   173

{

   174

	int best_veh_index = -1;

   175

	int32 best_veh_cost = 0;

   176

	int32 r;

   177

   178

	int i = AIRCRAFT_ENGINES_INDEX;

   179

	int end = i + NUM_AIRCRAFT_ENGINES;

   180

	Engine *e = &_engines[i];

   181

	do {

   182

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

   183

			continue;

   184

   185

		if (flag&1) {

   186

			if (i<253) continue;

   187

		} else {

   188

			if (i>=253) continue;

   189

		}

   190

   191

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

   192

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

   193

			best_veh_cost = r;

   194

			best_veh_index = i;

   195

		}

   196

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

   197

   198

	return best_veh_index;

   199

}

   200

   201

static int32 AiGetBasePrice(Player *p)

   202

{

   203

	int32 base = _price.station_value;

   204

   205

	// adjust base price when more expensive vehicles are available

   206

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

   207

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

   208

   209

	return base;

   210

}

   211

   212

#if 0

   213

static int AiChooseShipToBuild(byte cargo, int32 money)

   214

{

   215

	// XXX: not done

   216

	return 0;

   217

}

   218

#endif

   219

   220

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

   221

{

   222

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

   223

	return AiChooseRoadVehToBuild(v->cargo_type, avail_money);

   224

}

   225

   226

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

   227

{

   228

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

   229

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

   230

}

   231

   232

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

   233

{

   234

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

   235

	int num=0;

   236

	Vehicle *u = v;

   237

   238

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

   239

		u = u->next;

   240

	}

   241

   242

	// XXX: check if a wagon

   243

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

   244

}

   245

   246

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

   247

{

   248

	error("!AiChooseShipToReplaceWith");

   249

   250

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

   251

	return 0;

   252

}

   253

   254

static void AiHandleGotoDepot(Player *p, int cmd)

   255

{

   256

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

   257

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

   258

   259

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

   260

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   261

		return;

   262

	}

   263

   264

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

   265

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

   266

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

   267

	}

   268

} 

   269

   270

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

   271

{

   272

	uint16 *os = bak->order, ord;

   273

	int ind = 0;

   274

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

   275

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

   276

			break;

   277

		ind++;

   278

	}

   279

}

   280

   281

static void AiHandleReplaceTrain(Player *p)

   282

{

   283

	Vehicle *v = p->ai.cur_veh;

   284

	BackuppedOrders orderbak[1];

   285

	int veh;

   286

	uint tile;

   287

   288

	// wait until the vehicle reaches the depot.

   289

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

   290

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

   291

		return;

   292

	}

   293

   294

	veh = AiChooseTrainToReplaceWith(p, v);

   295

	if (veh != -1) {

   296

		BackupVehicleOrders(v, orderbak);

   297

		tile = v->tile;

   298

   299

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

   300

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

   301

			veh = _new_train_id;

   302

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   303

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

   304

			// Force the service interval to 180 days.. else things can go very wrong :p

   305

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

   306

		}

   307

	}

   308

}

   309

   310

static void AiHandleReplaceRoadVeh(Player *p)

   311

{

   312

	Vehicle *v = p->ai.cur_veh;

   313

	BackuppedOrders orderbak[1];

   314

	int veh;

   315

	uint tile;

   316

   317

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

   318

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

   319

		return;

   320

	}

   321

   322

	veh = AiChooseRoadVehToReplaceWith(p, v);

   323

	if (veh != -1) {

   324

		BackupVehicleOrders(v, orderbak);

   325

		tile = v->tile;

   326

   327

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

   328

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

   329

			veh = _new_roadveh_id;

   330

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   331

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

   332

			// Force the service interval to 180 days.. else things can go very wrong :p

   333

			DoCommandByTile(0, veh, 180, DC_EXEC, CMD_CHANGE_ROADVEH_SERVICE_INT);

   334

		}

   335

	}

   336

}

   337

   338

static void AiHandleReplaceAircraft(Player *p)

   339

{

   340

	Vehicle *v = p->ai.cur_veh;

   341

	int veh;

   342

	BackuppedOrders orderbak[1];

   343

	uint tile;

   344

   345

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

   346

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

   347

		return;

   348

	}

   349

   350

	veh = AiChooseAircraftToReplaceWith(p, v);

   351

	if (veh != -1) {

   352

		BackupVehicleOrders(v, orderbak);

   353

		tile = v->tile;

   354

   355

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

   356

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

   357

			veh = _new_aircraft_id;

   358

			AiRestoreVehicleOrders(&_vehicles[veh], orderbak);

   359

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

   360

			// Force the service interval to 180 days.. else things can go very wrong :p

   361

			DoCommandByTile(0, veh, 180, DC_EXEC, CMD_CHANGE_AIRCRAFT_SERVICE_INT);

   362

		}

   363

	}

   364

}

   365

   366

static void AiHandleReplaceShip(Player *p)

   367

{

   368

	error("!AiHandleReplaceShip");

   369

}

   370

   371

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

   372

   373

static CheckReplaceProc * const _veh_check_replace_proc[] = {

   374

	AiChooseTrainToReplaceWith,

   375

	AiChooseRoadVehToReplaceWith,

   376

	AiChooseShipToReplaceWith,

   377

	AiChooseAircraftToReplaceWith,

   378

};

   379

   380

typedef void DoReplaceProc(Player *p);

   381

static DoReplaceProc * const _veh_do_replace_proc[] = {

   382

	AiHandleReplaceTrain,

   383

	AiHandleReplaceRoadVeh,

   384

	AiHandleReplaceShip,

   385

	AiHandleReplaceAircraft

   386

};

   387

   388

static void AiStateCheckReplaceVehicle(Player *p)

   389

{

   390

	Vehicle *v = p->ai.cur_veh;

   391

   392

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

   393

		p->ai.state = AIS_VEH_LOOP;

   394

	} else {

   395

		p->ai.state_counter = 0;

   396

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

   397

	}

   398

}

   399

   400

static void AiStateDoReplaceVehicle(Player *p)

   401

{

   402

	Vehicle *v = p->ai.cur_veh;

   403

	p->ai.state = AIS_VEH_LOOP;

   404

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

   405

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

   406

		return;

   407

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

   408

}

   409

   410

typedef struct FoundRoute {

   411

	int distance;

   412

	byte cargo;

   413

	void *from;

   414

	void *to;

   415

} FoundRoute;

   416

   417

static Town *AiFindRandomTown() {

   418

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

   419

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

   420

}

   421

   422

static Industry *AiFindRandomIndustry() {

   423

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

   424

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

   425

}

   426

   427

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

   428

{

   429

	int i;

   430

	byte cargo;

   431

	Subsidy *s;

   432

	Industry *from, *to_ind;

   433

	Town *to_tow;

   434

	TileIndex to_xy;

   435

   436

	// initially error

   437

	fr->distance = -1;

   438

   439

	// Randomize subsidy index.. 

   440

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

   441

	if (i >= lengthof(_subsidies))

   442

		return;

   443

   444

	s = &_subsidies[i];

   445

   446

	// Don't want passengers or mail

   447

	cargo = s->cargo_type;

   448

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

   449

		return;

   450

	fr->cargo = cargo;

   451

   452

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

   453

   454

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

   455

		to_tow = DEREF_TOWN(s->to);

   456

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

   457

			return; // error

   458

		fr->to = to_tow;

   459

		to_xy = to_tow->xy;

   460

	} else {

   461

		to_ind = DEREF_INDUSTRY(s->to);

   462

		fr->to = to_ind;

   463

		to_xy = to_ind->xy;

   464

	}

   465

   466

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

   467

}

   468

   469

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

   470

{

   471

	uint i;

   472

	Subsidy *s;

   473

	Town *from,*to;

   474

   475

	// initially error

   476

	fr->distance = -1;

   477

   478

	// Randomize subsidy index.. 

   479

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

   480

	if (i >= lengthof(_subsidies))

   481

		return;

   482

   483

	s = &_subsidies[i];

   484

   485

	// Only want passengers

   486

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

   487

		return;

   488

	fr->cargo = s->cargo_type;

   489

   490

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

   491

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

   492

   493

	// They must be big enough

   494

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

   495

		return;

   496

   497

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

   498

}

   499

   500

static void AiFindRandomIndustryRoute(FoundRoute *fr)

   501

{

   502

	Industry *i,*i2;

   503

	Town *t;

   504

	uint32 r;

   505

	byte cargo;

   506

   507

	// initially error

   508

	fr->distance = -1;

   509

   510

	r = Random();

   511

   512

	// pick a source

   513

	fr->from = i = AiFindRandomIndustry();

   514

	if (i == NULL)	

   515

		return;

   516

   517

	// pick a random produced cargo

   518

	cargo = i->produced_cargo[0];

   519

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

   520

		cargo = i->produced_cargo[1];

   521

   522

	fr->cargo = cargo;

   523

   524

	// don't allow passengers

   525

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

   526

		return;

   527

   528

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