1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "table/strings.h"

     5

#include "map.h"

     6

#include "tile.h"

     7

#include "vehicle.h"

     8

#include "depot.h"

     9

#include "engine.h"

    10

#include "command.h"

    11

#include "station.h"

    12

#include "news.h"

    13

#include "gfx.h"

    14

#include "sound.h"

    15

#include "player.h"

    16

#include "airport.h"

    17

#include "vehicle_gui.h"

    18

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

static void CrashAirplane(Vehicle *v);

    26

    27

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    28

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    29

    30

static const SpriteID _aircraft_sprite[] = {

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

	0x0EBD, 0x0EC5

    38

};

    39

    40

/* Find the nearest hangar to v

    41

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

    42

 * airports (like helipads only)

    43

 */

    44

static StationID FindNearestHangar(const Vehicle *v)

    45

{

    46

	const Station *st;

    47

	uint best = 0;

    48

	StationID index = INVALID_STATION;

    49

    50

	FOR_ALL_STATIONS(st) {

    51

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

    52

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

    53

			uint distance;

    54

    55

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

    56

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

    57

					!_cheats.no_jetcrash.value)

    58

				continue;

    59

    60

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

    61

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

    62

				best = distance;

    63

				index = st->index;

    64

			}

    65

		}

    66

	}

    67

	return index;

    68

}

    69

    70

#if 0

    71

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

    72

static bool HaveHangarInOrderList(Vehicle *v)

    73

{

    74

	const Order *order;

    75

    76

	FOR_VEHICLE_ORDERS(v, order) {

    77

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

    78

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

    79

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

    80

			// it surely doesn't have any hangars

    81

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

    82

				return true;

    83

		}

    84

	}

    85

    86

	return false;

    87

}

    88

#endif

    89

    90

int GetAircraftImage(const Vehicle *v, byte direction)

    91

{

    92

	int spritenum = v->spritenum;

    93

    94

	if (is_custom_sprite(spritenum)) {

    95

		int sprite = GetCustomVehicleSprite(v, direction);

    96

    97

		if (sprite) return sprite;

    98

		spritenum = _engine_original_sprites[v->engine_type];

    99

	}

   100

	return direction + _aircraft_sprite[spritenum];

   101

}

   102

   103

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

   104

{

   105

	int spritenum = AircraftVehInfo(engine)->image_index;

   106

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

   107

   108

	if (is_custom_sprite(spritenum)) {

   109

		sprite = GetCustomVehicleIcon(engine, 6);

   110

		if (!sprite)

   111

			sprite = _engine_original_sprites[engine];

   112

	}

   113

   114

	DrawSprite(sprite | image_ormod, x, y);

   115

   116

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

   117

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

   118

	}

   119

}

   120

   121

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

   122

{

   123

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   124

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

   125

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

   126

	SetDParam(2, avi->passenger_capacity);

   127

	SetDParam(3, avi->mail_capacity);

   128

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

   129

   130

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   131

}

   132

   133

/* Allocate many vehicles */

   134

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

   135

{

   136

	int i;

   137

	Vehicle *v;

   138

	bool success = true;

   139

   140

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

   141

		vl[i] = v = AllocateVehicle();

   142

		if (v == NULL) {

   143

			success = false;

   144

			break;

   145

		}

   146

		v->type = 1;

   147

	}

   148

   149

	while (--i >= 0) {

   150

		vl[i]->type = 0;

   151

	}

   152

   153

	return success;

   154

}

   155

   156

int32 EstimateAircraftCost(EngineID engine_type)

   157

{

   158

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

   159

}

   160

   161

   162

/** Build an aircraft.

   163

 * @param x,y tile coordinates of depot where aircraft is built

   164

 * @param p1 aircraft type being built (engine)

   165

 * @param p2 unused

   166

 */

   167

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

   168

{

   169

	int32 value;

   170

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

   171

	UnitID unit_num;

   172

	TileIndex tile = TILE_FROM_XY(x,y);

   173

	const AircraftVehicleInfo *avi;

   174

	Engine *e;

   175

   176

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

   177

   178

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

   179

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

   180

   182

   183

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   184

   185

	value = EstimateAircraftCost(p1);

   186

   187

	if (flags & DC_QUERY_COST) return value;

   188

   189

	avi = AircraftVehInfo(p1);

   190

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

   191

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

   192

				IsOrderPoolFull())

   193

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   194

   195

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   196

	if (unit_num > _patches.max_aircraft)

   197

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   198

   199

	if (flags & DC_EXEC) {

   200

		v = vl[0];

   201

		u = vl[1];

   202

   203

		v->unitnumber = unit_num;

   204

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

   205

		v->direction = 3;

   206

   207

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

   208

   209

		v->tile = tile;

   210

//		u->tile = 0;

   211

   212

		x = TileX(tile) * 16 + 5;

   213

		y = TileY(tile) * 16 + 3;

   214

   215

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

   216

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

   217

   218

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

   219

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

   220

   221

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

   222

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

   223

   224

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

   225

		v->z_height = 5;

   226

   227

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

   228

		u->z_height = 1;

   229

   230

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   231

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   232

   233

		v->spritenum = avi->image_index;

   234

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

   235

   236

		v->cargo_cap = avi->passenger_capacity;

   237

		u->cargo_cap = avi->mail_capacity;

   238

   239

		v->cargo_type = CT_PASSENGERS;

   240

		u->cargo_type = CT_MAIL;

   241

   242

		v->string_id = STR_SV_AIRCRAFT_NAME;

   243

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

   244

   245

//		v->load_unload_time_rem = 0;

   246

//		v->progress = 0;

   247

		v->last_station_visited = INVALID_STATION;

   248

//		v->destination_coords = 0;

   249

   250

		v->max_speed = avi->max_speed;

   251

		v->acceleration = avi->acceleration;

   252

		v->engine_type = (byte)p1;

   253

   254

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

   255

		v->value = value;

   256

   257

		u->subtype = 4;

   258

   259

		e = &_engines[p1];

   260

		v->reliability = e->reliability;

   261

		v->reliability_spd_dec = e->reliability_spd_dec;

   262

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

   263

   264

		_new_aircraft_id = v->index;

   265

   266

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

   267

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

   268

		// On hold for NewAI

   269

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

   270

   271

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

   272

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

   273

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

   274

		*/

   275

		{

   276

			const Station* st = GetStation(_map2[tile]);

   277

			const AirportFTAClass* Airport = GetAirport(st->airport_type);

   278

			uint i;

   279

   280

			for (i = 0; i < Airport->nof_depots; i++) {

   281

				if (st->airport_tile + ToTileIndexDiff(Airport->airport_depots[i]) == tile) {

   282

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

   283

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

   284

					break;

   285

				}

   286

			}

   287

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

   288

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

   289

		}

   290

   291

		v->u.air.state = HANGAR;

   292

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

   293

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

   294

		v->next = u;

   295

   296

		v->service_interval = _patches.servint_aircraft;

   297

   298

		v->date_of_last_service = _date;

   299

		v->build_year = u->build_year = _cur_year;

   300

   301

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

   302

   303

		VehiclePositionChanged(v);

   304

		VehiclePositionChanged(u);

   305

   306

		// Aircraft with 3 vehicles (chopper)?

   307

		if (v->subtype == 0) {

   308

			w = vl[2];

   309

   310

			u->next = w;

   311

   312

			w->type = VEH_Aircraft;

   313

			w->direction = 0;

   314

			w->owner = _current_player;

   315

			w->x_pos = v->x_pos;

   316

			w->y_pos = v->y_pos;

   317

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

   318

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

   319

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

   320

			w->z_height = 1;

   321

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   322

			w->subtype = 6;

   323

			w->cur_image = 0xF3D;

   324

			VehiclePositionChanged(w);

   325

		}

   326

   327

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   328

		RebuildVehicleLists();

   329

		InvalidateWindow(WC_COMPANY, v->owner);

   330

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

   331

	}

   332

   333

	return value;

   334

}

   335

   336

bool IsAircraftHangarTile(TileIndex tile)

   337

{

   338

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

   339

	// 0x20 - hangar large airport (32)

   340

	// 0x41 - hangar small airport (65)

   341

	return IsTileType(tile, MP_STATION) &&

   342

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

   343

}

   344

   345

static bool CheckStoppedInHangar(Vehicle *v)

   346

{

   347

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

   348

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   349

		return false;

   350

	}

   351

   352

	return true;

   353

}

   354

   355

   356

static void DoDeleteAircraft(Vehicle *v)

   357

{

   358

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   359

	RebuildVehicleLists();

   360

	InvalidateWindow(WC_COMPANY, v->owner);

   361

	DeleteVehicleChain(v);

   362

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   363

}

   364

   365

/** Sell an aircraft.

   366

 * @param x,y unused

   367

 * @param p1 vehicle ID to be sold

   368

 * @param p2 unused

   369

 */

   370

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

   371

{

   372

	Vehicle *v;

   373

   374

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   375

   376

	v = GetVehicle(p1);

   377

   378

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

   379

		return CMD_ERROR;

   380

   381

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   382

   383

	if (flags & DC_EXEC) {

   384

		// Invalidate depot

   385

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   386

		DoDeleteAircraft(v);

   387

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

   388

	}

   389

   390

	return -(int32)v->value;

   391

}

   392

   393

/** Start/Stop an aircraft.

   394

 * @param x,y unused

   395

 * @param p1 aircraft ID to start/stop

   396

 * @param p2 unused

   397

 */

   398

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

   399

{

   400

	Vehicle *v;

   401

   402

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   403

   404

	v = GetVehicle(p1);

   405

   406

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

   407

   408

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

   409

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

   410

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   411

   412

	if (flags & DC_EXEC) {

   413

		v->vehstatus ^= VS_STOPPED;

   414

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

   415

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   416

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   417

	}

   418

   419

	return 0;

   420

}

   421

   422

/** Send an aircraft to the hangar.

   423

 * @param x,y unused

   424

 * @param p1 vehicle ID to send to the hangar

   425

 * @param p2 various bitmasked elements

   426

 * - p2 = 0      - aircraft goes to the depot and stays there (user command)

   427

 * - p2 non-zero - aircraft will try to goto a depot, but not stop there (eg forced servicing)

   428

 * - p2 (bit 17) - aircraft will try to goto a depot at the next airport

   429

 */

   430

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

   431

{

   432

	Vehicle *v;

   433

   434

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   435

   436

	v = GetVehicle(p1);

   437

   438

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

   439

   440

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

   441

		if (flags & DC_EXEC) {

   442

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

   443

			v->current_order.type = OT_DUMMY;

   444

			v->current_order.flags = 0;

   445

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

   446

		}

   447

	} else {

   448

		bool next_airport_has_hangar = true;

   449

		/* XXX - I don't think p2 is any valid station cause all calls use either 0, 1, or 1<<16!!!!!!!!! */

   450

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

   451

		const Station *st = GetStation(next_airport_index);

   452

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

   453

		// it surely doesn't have any hangars

   454

		if (!IsValidStation(st) || st->airport_tile == 0 || GetAirport(st->airport_type)->nof_depots == 0) {

   455

			StationID station;

   456

   457

			if (p2 != 0) return CMD_ERROR;

   458

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

   459

			station = FindNearestHangar(v);

   460

   461

			next_airport_has_hangar = false;

   462

			if (station == INVALID_STATION) return CMD_ERROR;

   463

			st = GetStation(station);

   464

			next_airport_index = station;

   465

   466

		}

   467

   468

		if (flags & DC_EXEC) {

   469

			v->current_order.type = OT_GOTO_DEPOT;

   470

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

   471

			v->current_order.station = next_airport_index;

   472

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

   473

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

   474

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

   475

				AircraftNextAirportPos_and_Order(v);

   476

				v->u.air.targetairport = next_airport_index;

   477

			}

   478

		}

   479

	}

   480

   481

	return 0;

   482

}

   483

   484

/** Change the service interval for aircraft.

   485

 * @param x,y unused

   486

 * @param p1 vehicle ID that is being service-interval-changed

   487

 * @param p2 new service interval

   488

 */

   489

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

   490

{

   491

	Vehicle *v;

   492

	uint16 serv_int = GetServiceIntervalClamped(p2); /* Double check the service interval from the user-input */

   493

   494

	if (serv_int != p2 || !IsVehicleIndex(p1)) return CMD_ERROR;

   495

   496

	v = GetVehicle(p1);

   497

   498

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

   499

   500

	if (flags & DC_EXEC) {

   501

		v->service_interval = serv_int;

   502

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

   503

	}

   504