1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "table/strings.h"

     5

#include "map.h"

     6

#include "tile.h"

     7

#include "vehicle.h"

     8

#include "engine.h"

     9

#include "command.h"

    10

#include "station.h"

    11

#include "news.h"

    12

#include "gfx.h"

    13

#include "sound.h"

    14

#include "player.h"

    15

#include "airport.h"

    16

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

static void CrashAirplane(Vehicle *v);

    24

    25

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    26

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    27

    28

static const SpriteID _aircraft_sprite[] = {

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

	0x0EBD, 0x0EC5

    36

};

    37

    38

/* Find the nearest hangar to v

    39

 * INVALID_STATION is returned, if the player does not have any suitable

    40

 * airports (like helipads only)

    41

 */

    42

static uint16 FindNearestHangar(const Vehicle *v)

    43

{

    44

	const Station *st;

    45

	uint best = 0;

    46

	uint16 index = INVALID_STATION;

    47

    48

	FOR_ALL_STATIONS(st) {

    49

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

    50

				GetAirport(st->airport_type)->nof_depots > 0) {

    51

			uint distance;

    52

    53

			// don't crash the plane if we know it can't land at the airport

    54

			if (HASBIT(v->subtype, 1) && st->airport_type == AT_SMALL &&

    55

					!_cheats.no_jetcrash.value)

    56

				continue;

    57

    58

			distance = DistanceSquare(v->tile, st->airport_tile);

    59

			if (distance < best || index == INVALID_STATION) {

    60

				best = distance;

    61

				index = st->index;

    62

			}

    63

		}

    64

	}

    65

	return index;

    66

}

    67

    68

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

    69

static bool HaveHangarInOrderList(Vehicle *v)

    70

{

    71

	const Order *order;

    72

    73

	FOR_VEHICLE_ORDERS(v, order) {

    74

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

    75

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

    76

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

    77

			// it surely doesn't have any hangars

    78

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

    79

				return true;

    80

		}

    81

	}

    82

    83

	return false;

    84

}

    85

    86

int GetAircraftImage(Vehicle *v, byte direction)

    87

{

    88

	int spritenum = v->spritenum;

    89

    90

	if (is_custom_sprite(spritenum)) {

    91

		int sprite = GetCustomVehicleSprite(v, direction);

    92

    93

		if (sprite) return sprite;

    94

		spritenum = _engine_original_sprites[v->engine_type];

    95

	}

    96

	return direction + _aircraft_sprite[spritenum];

    97

}

    98

    99

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

   100

{

   101

	int spritenum = AircraftVehInfo(engine)->image_index;

   102

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

   103

   104

	if (is_custom_sprite(spritenum)) {

   105

		sprite = GetCustomVehicleIcon(engine, 6);

   106

		if (!sprite)

   107

			sprite = _engine_original_sprites[engine];

   108

	}

   109

   110

	DrawSprite(sprite | image_ormod, x, y);

   111

   112

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

   113

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

   114

	}

   115

}

   116

   117

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

   118

{

   119

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   120

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

   121

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

   122

	SetDParam(2, avi->passenger_capacity);

   123

	SetDParam(3, avi->mail_capacity);

   124

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

   125

   126

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   127

}

   128

   129

/* Allocate many vehicles */

   130

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

   131

{

   132

	int i;

   133

	Vehicle *v;

   134

	bool success = true;

   135

   136

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

   137

		vl[i] = v = AllocateVehicle();

   138

		if (v == NULL) {

   139

			success = false;

   140

			break;

   141

		}

   142

		v->type = 1;

   143

	}

   144

   145

	while (--i >= 0) {

   146

		vl[i]->type = 0;

   147

	}

   148

   149

	return success;

   150

}

   151

   152

int32 EstimateAircraftCost(uint16 engine_type)

   153

{

   154

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

   155

}

   156

   157

   158

/* p1 = engine */

   159

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

   160

{

   161

	int32 value;

   162

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

   163

	UnitID unit_num;

   165

	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

   166

	Engine *e;

   167

   168

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

   169

   170

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

   172

   173

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

   174

   175

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   176

   177

	value = EstimateAircraftCost(p1);

   178

   179

	if (flags & DC_QUERY_COST)

   180

		return value;

   181

   182

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

   183

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

   184

				IsOrderPoolFull())

   185

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   186

   187

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   188

	if (unit_num > _patches.max_aircraft)

   189

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   190

   191

	if (flags & DC_EXEC) {

   192

		v = vl[0];

   193

		u = vl[1];

   194

   195

		v->unitnumber = unit_num;

   196

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

   197

		v->direction = 3;

   198

   199

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

   200

   201

		v->tile = tile;

   202

//		u->tile = 0;

   203

   204

		x = TileX(tile) * 16 + 5;

   205

		y = TileY(tile) * 16 + 3;

   206

   207

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

   208

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

   209

   210

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

   211

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

   212

   213

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

   214

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

   215

   216

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

   217

		v->z_height = 5;

   218

   219

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

   220

		u->z_height = 1;

   221

   222

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   223

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   224

   225

		v->spritenum = avi->image_index;

   226

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

   227

   228

		v->cargo_cap = avi->passenger_capacity;

   229

		u->cargo_cap = avi->mail_capacity;

   230

   231

		v->cargo_type = CT_PASSENGERS;

   232

		u->cargo_type = CT_MAIL;

   233

   234

		v->string_id = STR_SV_AIRCRAFT_NAME;

   235

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

   236

   237

//		v->load_unload_time_rem = 0;

   238

//		v->progress = 0;

   239

		v->last_station_visited = INVALID_STATION;

   240

//		v->destination_coords = 0;

   241

   242

		v->max_speed = avi->max_speed;

   243

		v->acceleration = avi->acceleration;

   244

		v->engine_type = (byte)p1;

   245

   246

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

   247

		v->value = value;

   248

   249

		u->subtype = 4;

   250

   251

		e = &_engines[p1];

   252

		v->reliability = e->reliability;

   253

		v->reliability_spd_dec = e->reliability_spd_dec;

   254

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

   255

   256

		_new_aircraft_id = v->index;

   257

   258

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

   259

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

   260

		// On hold for NewAI

   261

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

   262

   263

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

   264

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

   265

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

   266

		*/

   267

		{

   274

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

   275

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

   276

					break;

   277

				}

   278

			}

   279

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

   280

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

   281

		}

   282

   283

		v->u.air.state = HANGAR;

   284

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

   285

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

   286

		v->next = u;

   287

   288

		v->service_interval = _patches.servint_aircraft;

   289

   290

		v->date_of_last_service = _date;

   291

		v->build_year = _cur_year;

   292

   293

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

   294

   295

		VehiclePositionChanged(v);

   296

		VehiclePositionChanged(u);

   297

   298

		// Aircraft with 3 vehicles?

   299

		if (v->subtype == 0) {

   300

			w = vl[2];

   301

   302

			u->next = w;

   303

   304

			w->type = VEH_Aircraft;

   305

			w->direction = 0;

   306

			w->owner = _current_player;

   307

			w->x_pos = v->x_pos;

   308

			w->y_pos = v->y_pos;

   309

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

   310

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

   311

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

   312

			w->z_height = 1;

   313

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   314

			w->subtype = 6;

   315

			w->cur_image = 0xF3D;

   316

			VehiclePositionChanged(w);

   317

		}

   318

   319

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   320

		RebuildVehicleLists();

   321

		InvalidateWindow(WC_COMPANY, v->owner);

   322

	}

   323

   324

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

   325

   326

	return value;

   327

}

   328

   329

bool IsAircraftHangarTile(TileIndex tile)

   330

{

   331

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

   332

	// 0x20 - hangar large airport (32)

   333

	// 0x41 - hangar small airport (65)

   334

	return IsTileType(tile, MP_STATION) &&

   335

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

   336

}

   337

   338

static bool CheckStoppedInHangar(Vehicle *v)

   339

{

   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

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   364

   365

	v = GetVehicle(p1);

   366

   367

	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner) || !CheckStoppedInHangar(v))

   368

		return CMD_ERROR;

   369

   370

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   371

   372

	if (flags & DC_EXEC) {

   373

		// Invalidate depot

   374

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   375

		DoDeleteAircraft(v);

   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

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   389

   390

	v = GetVehicle(p1);

   391

   392

	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner))

   393

		return CMD_ERROR;

   394

   395

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

   396

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

   397

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   398

	}

   399

   400

	if (flags & DC_EXEC) {

   401

		v->vehstatus ^= VS_STOPPED;

   402

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

   403

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   404

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   405

	}

   406

   407

	return 0;

   408

}

   409

   410

// p1 = vehicle

   411

// p2 = if set, the aircraft will try to goto a depot, but not stop

   412

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

   413

{

   414

	Vehicle *v;

   415

	Station *st;

   416

	uint16 next_airport_index;

   417

   418

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   419

   420

	v = GetVehicle(p1);

   421

   422

	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner))

   423

		return CMD_ERROR;

   424

   425

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

   426

		if (flags & DC_EXEC) {

   427

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

   428

			v->current_order.type = OT_DUMMY;

   429

			v->current_order.flags = 0;

   430

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

   431

		}

   432

	} else {

   433

		bool next_airport_has_hangar = true;

   434

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

   435

		st = GetStation(next_airport_index);

   436

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

   437

		// it surely doesn't have any hangars

   438

		if (st->xy == 0 || st->airport_tile == 0 ||

   439

				GetAirport(st->airport_type)->nof_depots == 0) {

   440

			if (p2 == 0) {

   441

				// the aircraft has to search for a hangar on its own

   442

				uint16 station = FindNearestHangar(v);

   443

   444

				next_airport_has_hangar = false;

   445

				if (station == INVALID_STATION) return CMD_ERROR;

   446

				st = GetStation(station);

   447

				next_airport_index = station;

   448

			} else {

   449

				return CMD_ERROR;

   450

			}

   451

		}

   452

   453

		if (flags & DC_EXEC) {

   454

			v->current_order.type = OT_GOTO_DEPOT;

   455

			v->current_order.flags = HASBIT(p2, 16) ? 0 : OF_NON_STOP | OF_FULL_LOAD;

   456

			v->current_order.station = next_airport_index;

   457

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

   458

			if (HASBIT(p2, 17) || (p2 == 0 && v->u.air.state == FLYING && !next_airport_has_hangar)) {

   459

			// the aircraft is now heading for a different hangar than the next in the orders

   460

				AircraftNextAirportPos_and_Order(v);

   461

				v->u.air.targetairport = next_airport_index;

   462

			}

   463

		}

   464

	}

   465

   466

	return 0;

   467

}

   468

   469

// p1 = vehicle

   470

// p2 = new service int

   471

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

   472

{

   473

	Vehicle *v;

   474

   475

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   476

   477

	v = GetVehicle(p1);

   478

   479

	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner))

   480

		return CMD_ERROR;

   481

   482

	if (flags & DC_EXEC) {

   483

		v->service_interval = (uint16)p2;

   484

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

   485

	}

   486

   487

	return 0;

   488

}

   489

   490

// p1 = vehicle

   491

// p2 = new cargo type(0xFF)

   492

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

   493

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

   494

{

   495

	Vehicle *v,*u;

   496

	int pass, mail;

   497

	int32 cost;

   498

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

   499

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

   500

	AircraftVehicleInfo *avi;

   501

   502

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   503

   504

	v = GetVehicle(p1);

   505

   506

	if (v->type != VEH_Aircraft) return CMD_ERROR;

   507