1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "vehicle.h"

     7

#include "engine.h"

     8

#include "command.h"

     9

#include "station.h"

    10

#include "news.h"

    11

#include "gfx.h"

    12

#include "sound.h"

    13

#include "player.h"

    14

#include "airport.h"

    15

    16

static bool AirportMove(Vehicle *v, const AirportFTAClass *Airport);

    17

static bool AirportSetBlocks(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport);

    18

static bool AirportHasBlock(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport);

    19

static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *Airport);

    20

static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *Airport);

    21

static void AirportGoToNextPosition(Vehicle *v, const AirportFTAClass *Airport);

    22

static void CrashAirplane(Vehicle *v);

    23

    24

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    25

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    26

    27

static const SpriteID _aircraft_sprite[] = {

    28

	0x0EB5, 0x0EBD, 0x0EC5, 0x0ECD,

    29

	0x0ED5, 0x0EDD, 0x0E9D, 0x0EA5,

    30

	0x0EAD, 0x0EE5, 0x0F05, 0x0F0D,

    31

	0x0F15, 0x0F1D, 0x0F25, 0x0F2D,

    32

	0x0EED, 0x0EF5, 0x0EFD, 0x0F35,

    33

	0x0E9D, 0x0EA5, 0x0EAD, 0x0EB5,

    34

	0x0EBD, 0x0EC5

    35

};

    36

    37

// use this to find the nearest hangar to v

    38

// bit 16 is set in the return value if the player do not have any airports with a hangar (like helipads only)

    39

static uint32 FindNearestHangar(Vehicle *v)

    40

{

    41

	Station *st;

    42

	uint temp_distance, distance = 0xFFFF;

    43

	uint16 index_to_target = 0;

    44

    45

	FOR_ALL_STATIONS(st) {

    46

		if (st->owner == v->owner && st->facilities & FACIL_AIRPORT) {

    47

			if (GetAirport(st->airport_type)->terminals != NULL) {

    48

				// don't crash the planes if we know they can't land at the airport

    49

				if (HASBIT(v->subtype,1) && st->airport_type == AT_SMALL && !_cheats.no_jetcrash.value) continue;

    50

    51

				temp_distance = GetTileDistAdv(v->tile, st->airport_tile);

    52

				if (temp_distance < distance) {

    53

					distance = temp_distance;

    54

					index_to_target = st->index;

    55

				}

    56

			}

    57

		}

    58

	}

    59

	if (distance == 65000)

    60

		SETBIT(index_to_target, 16);

    61

	return index_to_target;

    62

}

    63

    64

// returns true if vehicle v have an airport in the schedule, that has a hangar

    65

static bool HaveHangarInOrderList(Vehicle *v)

    66

{

    67

	const Order *order;

    68

    69

	FOR_VEHICLE_ORDERS(v, order) {

    70

		const Station *st = GetStation(order->station);

    71

		if (st->owner == v->owner && st->facilities & FACIL_AIRPORT) {

    72

			// If an airport doesn't have terminals (so no landing space for airports),

    73

			// it surely doesn't have any hangars

    74

			if (GetAirport(st->airport_type)->terminals != NULL)

    75

				return true;

    76

		}

    77

	}

    78

    79

	return false;

    80

}

    81

    82

int GetAircraftImage(Vehicle *v, byte direction)

    83

{

    84

	int spritenum = v->spritenum;

    85

    86

	if (is_custom_sprite(spritenum)) {

    87

		int sprite = GetCustomVehicleSprite(v, direction);

    88

    89

		if (sprite) return sprite;

    90

		spritenum = _engine_original_sprites[v->engine_type];

    91

	}

    92

	return direction + _aircraft_sprite[spritenum];

    93

}

    94

    95

void DrawAircraftEngine(int x, int y, int engine, uint32 image_ormod)

    96

{

    97

	int spritenum = AircraftVehInfo(engine)->image_index;

    98

	int sprite = (6 + _aircraft_sprite[spritenum]);

    99

   100

	if (is_custom_sprite(spritenum)) {

   101

		sprite = GetCustomVehicleIcon(engine, 6);

   102

		if (!sprite)

   103

			sprite = _engine_original_sprites[engine];

   104

	}

   105

   106

	DrawSprite(sprite | image_ormod, x, y);

   107

   108

	if ((AircraftVehInfo(engine)->subtype & 1) == 0) {

   109

		DrawSprite(0xF3D, x, y-5);

   110

	}

   111

}

   112

   113

void DrawAircraftEngineInfo(int engine, int x, int y, int maxw)

   114

{

   115

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   116

	SetDParam(0, ((_price.aircraft_base >> 3) * avi->base_cost) >> 5);

   117

	SetDParam(1, avi->max_speed << 3);

   118

	SetDParam(2, avi->passenger_capacity);

   119

	SetDParam(3, avi->mail_capacity);

   120

	SetDParam(4, avi->running_cost * _price.aircraft_running >> 8);

   121

   122

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   123

}

   124

   125

/* Allocate many vehicles */

   126

static bool AllocateVehicles(Vehicle **vl, int num)

   127

{

   128

	int i;

   129

	Vehicle *v;

   130

	bool success = true;

   131

   132

	for(i=0; i!=num; i++) {

   133

		vl[i] = v = AllocateVehicle();

   134

		if (v == NULL) {

   135

			success = false;

   136

			break;

   137

		}

   138

		v->type = 1;

   139

	}

   140

   141

	while (--i >= 0) {

   142

		vl[i]->type = 0;

   143

	}

   144

   145

	return success;

   146

}

   147

   148

int32 EstimateAircraftCost(uint16 engine_type)

   149

{

   150

	return AircraftVehInfo(engine_type)->base_cost * (_price.aircraft_base>>3)>>5;

   151

}

   152

   153

   154

/* p1 = engine */

   155

int32 CmdBuildAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   156

{

   157

	int32 value;

   158

	Vehicle *vl[3], *v, *u, *w;

   159

	byte unit_num;

   160

	uint tile = TILE_FROM_XY(x,y);

   161

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   162

	Engine *e;

   163

   164

	if (!IsEngineBuildable(p1, VEH_Aircraft)) return CMD_ERROR;

   165

   166

	// Workaround: TODO: make AI players try to build planes in a hangar instead of just an airport tile.

   167

	if (!IsAircraftHangarTile((TileIndex)tile) && IS_HUMAN_PLAYER(_current_player)) return CMD_ERROR;

   168

   169

	if (_map_owner[tile] != _current_player) return CMD_ERROR;

   170

   171

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   172

   173

	value = EstimateAircraftCost(p1);

   174

   175

	if (flags & DC_QUERY_COST)

   176

		return value;

   177

   178

	// allocate 2 or 3 vehicle structs, depending on type

   179

	if (!AllocateVehicles(vl, (avi->subtype & 1) == 0 ? 3 : 2) ||

   180

				IsOrderPoolFull())

   181

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   182

   183

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   184

	if (unit_num > _patches.max_aircraft)

   185

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   186

   187

	if (flags & DC_EXEC) {

   188

		v = vl[0];

   189

		u = vl[1];

   190

   191

		v->unitnumber = unit_num;

   192

		v->type = u->type = VEH_Aircraft;

   193

		v->direction = 3;

   194

   195

		v->owner = u->owner = _current_player;

   196

   197

		v->tile = tile;

   198

//		u->tile = 0;

   199

   200

		x = TileX(tile) * 16 + 5;

   201

		y = TileY(tile) * 16 + 3;

   202

   203

		v->x_pos = u->x_pos = x;

   204

		v->y_pos = u->y_pos = y;

   205

   206

		u->z_pos = GetSlopeZ(x, y);

   207

		v->z_pos = u->z_pos + 1;

   208

   209

		v->x_offs = v->y_offs = -1;

   210

//		u->delta_x = u->delta_y = 0;

   211

   212

		v->sprite_width = v->sprite_height = 2;

   213

		v->z_height = 5;

   214

   215

		u->sprite_width = u->sprite_height = 2;

   216

		u->z_height = 1;

   217

   218

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   219

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   220

   221

		v->spritenum = avi->image_index;

   222

//		v->cargo_count = u->number_of_pieces = 0;

   223

   224

		v->cargo_cap = avi->passenger_capacity;

   225

		u->cargo_cap = avi->mail_capacity;

   226

   227

		v->cargo_type = CT_PASSENGERS;

   228

		u->cargo_type = CT_MAIL;

   229

   230

		v->string_id = STR_SV_AIRCRAFT_NAME;

   231

//		v->next_order_param = v->next_order = 0;

   232

   233

//		v->load_unload_time_rem = 0;

   234

//		v->progress = 0;

   235

		v->last_station_visited = 0xFFFF;

   236

//		v->destination_coords = 0;

   237

   238

		v->max_speed = avi->max_speed;

   239

		v->acceleration = avi->acceleration;

   240

		v->engine_type = (byte)p1;

   241

   242

		v->subtype = (avi->subtype & 1) == 0 ? 0 : 2;

   243

		v->value = value;

   244

   245

		u->subtype = 4;

   246

   247

		e = &_engines[p1];

   248

		v->reliability = e->reliability;

   249

		v->reliability_spd_dec = e->reliability_spd_dec;

   250

		v->max_age = e->lifelength * 366;

   251

   252

		_new_aircraft_id = v->index;

   253

   254

		// the AI doesn't click on a tile to build airplanes, so the below code will

   255

		// never work. Therefore just assume the AI's planes always come from Hangar0

   256

		// On hold for NewAI

   257

		v->u.air.pos = (!_patches.ainew_active && _is_ai_player) ? 0:MAX_ELEMENTS;

   258

   259

		/* When we click on hangar we know the tile (it is in var 'tile')it is on. By that we know

   260

			its position in the array of depots the airport has.....we can search

   261

			->layout for #th position of depot. Since layout must start with depots, it is simple

   262

		*/

   263

		{

   264

			Station *st;

   265

			const AirportFTAClass *Airport;

   266

			const TileIndexDiffC *cur_depot;

   267

			byte i = 0;

   268

			st = GetStation(_map2[tile]);

   269

			Airport = GetAirport(st->airport_type);

   270

			for (cur_depot = Airport->airport_depots; i != Airport->nof_depots; cur_depot++) {

   271

				if ((uint)(st->airport_tile + ToTileIndexDiff(*cur_depot)) == tile) {

   272

					assert(Airport->layout[i].heading == HANGAR);

   273

					v->u.air.pos = Airport->layout[i].position;

   274

					break;

   275

				}

   276

				i++;

   277

			}

   278

			// to ensure v->u.air.pos has been given a value

   279

			assert(v->u.air.pos != MAX_ELEMENTS);

   280

		}

   281

   282

		v->u.air.state = HANGAR;

   283

		v->u.air.previous_pos = v->u.air.pos;

   284

		v->u.air.targetairport = _map2[tile];

   285

		v->next = u;

   286

   287

		v->service_interval = _patches.servint_aircraft;

   288

   289

		v->date_of_last_service = _date;

   290

		v->build_year = _cur_year;

   291

   292

		v->cur_image = u->cur_image = 0xEA0;

   293

   294

		VehiclePositionChanged(v);

   295

		VehiclePositionChanged(u);

   296

   297

		// Aircraft with 3 vehicles?

   298

		if (v->subtype == 0) {

   299

			w = vl[2];

   300

   301

			u->next = w;

   302

   303

			w->type = VEH_Aircraft;

   304

			w->direction = 0;

   305

			w->owner = _current_player;

   306

			w->x_pos = v->x_pos;

   307

			w->y_pos = v->y_pos;

   308

			w->z_pos = v->z_pos + 5;

   309

			w->x_offs = w->y_offs = -1;

   310

			w->sprite_width = w->sprite_height = 2;

   311

			w->z_height = 1;

   312

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   313

			w->subtype = 6;

   314

			w->cur_image = 0xF3D;

   315

			VehiclePositionChanged(w);

   316

		}

   317

   318

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   319

		RebuildVehicleLists();

   320

		InvalidateWindow(WC_COMPANY, v->owner);

   321

	}

   322

   323

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Aircraft); //updates the replace Aircraft window

   324

   325

	return value;

   326

}

   327

   328

bool IsAircraftHangarTile(TileIndex tile)

   329

{

   330

	// 0x56 - hangar facing other way international airport (86)

   331

	// 0x20 - hangar large airport (32)

   332

	// 0x41 - hangar small airport (65)

   333

	return IsTileType(tile, MP_STATION) &&

   334

				(_map5[tile] == 32 || _map5[tile] == 65 || _map5[tile] == 86);

   335

}

   336

   337

static bool CheckStoppedInHangar(Vehicle *v)

   338

{

   339

	if (!(v->vehstatus&VS_STOPPED) ||

   340

			!IsAircraftHangarTile(v->tile)) {

   341

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   342

		return false;

   343

	}

   344

   345

	return true;

   346

}

   347

   348

   349

static void DoDeleteAircraft(Vehicle *v)

   350

{

   351

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   352

	RebuildVehicleLists();

   353

	InvalidateWindow(WC_COMPANY, v->owner);

   354

	DeleteVehicleChain(v);

   355

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   356

}

   357

   358

// p1 = vehicle

   359

int32 CmdSellAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   360

{

   361

	Vehicle *v;

   362

   363

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   364

   365

	v = GetVehicle(p1);

   366

   367

	if (!CheckOwnership(v->owner) || !CheckStoppedInHangar(v))

   368

		return CMD_ERROR;

   369

   370

	if (flags & DC_EXEC) {

   371

		// Invalidate depot

   372

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   373

   374

		DoDeleteAircraft(v);

   375

   376

	}

   377

   378

	InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Aircraft); // updates the replace Aircraft window

   379

   380

	return -(int32)v->value;

   381

}

   382

   383

// p1 = vehicle

   384

int32 CmdStartStopAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   385

{

   386

	Vehicle *v;

   387

   388

	v = GetVehicle(p1);

   389

   390

	if (!CheckOwnership(v->owner))

   391

		return CMD_ERROR;

   392

   393

	// cannot stop airplane when in flight, or when taking off / landing

   394

	if (v->u.air.state >= STARTTAKEOFF) {

   395

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   396

	}

   397

   398

	if (flags & DC_EXEC) {

   399

		v->vehstatus ^= VS_STOPPED;

   400

		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);

   401

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   402

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   403

	}

   404

   405

	return 0;

   406

}

   407

   408

/*  Send an aircraft to the hangar in the next station

   409

	p1 = index of the aircraft

   410

	p2 = bit 0..15 = index of station with hangar to use (only used if bit 17 is set)

   411

		 bit 16 = set v->set_for_replacement & do not stop in hangar

   412

		 bit 17 = goto the hangar in airport given in bit 0..15 instead of next stop

   413

		 bit 18 = clear v->set_for_replacement */

   414

int32 CmdSendAircraftToHangar(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   415

{

   416

	Vehicle *v;

   417

	Station *st;

   418

	uint16 next_airport_index;

   419

   420

	v = GetVehicle(p1);

   421

   422

	if (!CheckOwnership(v->owner))

   423

		return CMD_ERROR;

   424

   425

	if (HASBIT(p2, 16)) v->set_for_replacement = true; //now all clients knows that the vehicle wants to be replaced

   426

   427

	if (HASBIT(p2, 18)) {

   428

		v->set_for_replacement = false;

   429

		return CMD_ERROR; // no need to send aircraft to a depot. We just told that it don't have to anymore

   430

	}

   431

   432

	if (v->current_order.type == OT_GOTO_DEPOT && p2 == 0) {

   433

		if (flags & DC_EXEC) {

   434

			if (v->current_order.flags & OF_UNLOAD) v->cur_order_index++;

   435

			v->current_order.type = OT_DUMMY;

   436

			v->current_order.flags = 0;

   437

			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);

   438

		}

   439

	} else {

   440

		next_airport_index = (HASBIT(p2, 17)) ? (int16)p2 : v->u.air.targetairport;

   441

		st = GetStation(next_airport_index);

   442

		// If an airport doesn't have terminals (so no landing space for airports),

   443

		// it surely doesn't have any hangars

   444

		if (st->xy == 0 || st->airport_tile == 0 || GetAirport(st->airport_type)->terminals == NULL)

   445

					return CMD_ERROR;

   446

   447

		if (flags & DC_EXEC) {

   448

			v->current_order.type = OT_GOTO_DEPOT;

   449

			v->current_order.flags = v->set_for_replacement ? 0 : OF_NON_STOP | OF_FULL_LOAD;

   450

			v->current_order.station = next_airport_index;

   451

			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);

   452

			if (HASBIT(p2, 17)) {

   453

				AircraftNextAirportPos_and_Order(v);

   454

				v->u.air.targetairport = next_airport_index;

   455

			}

   456

		}

   457

	}

   458

   459

	return 0;

   460

}

   461

   462

// p1 = vehicle

   463

// p2 = new service int

   464

int32 CmdChangeAircraftServiceInt(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   465

{

   466

	Vehicle *v;

   467

   468

	v = GetVehicle(p1);

   469

   470

	if (!CheckOwnership(v->owner))

   471

		return CMD_ERROR;

   472

   473

	if (flags & DC_EXEC) {

   474

		v->service_interval = (uint16)p2;

   475

		InvalidateWindowWidget(WC_VEHICLE_DETAILS, v->index, 7);

   476

	}

   477

   478

	return 0;

   479

}

   480

   481

// p1 = vehicle

   482

// p2 = new cargo type(0xFF)

   483

// p2 = skip check for stopped in hanger (0x0100)

   484

int32 CmdRefitAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   485

{

   486

	Vehicle *v,*u;

   487

	int pass, mail;

   488

	int32 cost;

   489

	byte SkipStoppedInHangerCheck = (p2 & 0x100) >> 8; //excludes the cargo value

   490

	byte new_cargo_type = p2 & 0xFF; //gets the cargo number

   491

	AircraftVehicleInfo *avi;

   492

   493

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

   494

   495

	v = GetVehicle(p1);

   496

	avi = AircraftVehInfo(v->engine_type);

   497

	if (!CheckOwnership(v->owner) || (!CheckStoppedInHangar(v) && !(SkipStoppedInHangerCheck)))

   498

		return CMD_ERROR;

   499

   500

	switch (new_cargo_type) {

   501

		case CT_PASSENGERS:

   502

			pass = avi->passenger_capacity;

   503

			break;

   504

		case CT_MAIL:

   505

			pass = avi->passenger_capacity + avi->mail_capacity;

   506

			break;

   507

		case CT_GOODS:

   508

			pass = avi->passenger_capacity + avi->mail_capacity;

   509

			pass /= 2;

   510

			break;