1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     5

#include "table/strings.h"

     6

#include "map.h"

     7

#include "tile.h"

     8

#include "vehicle.h"

     9

#include "depot.h"

    10

#include "engine.h"

    11

#include "command.h"

    12

#include "station.h"

    13

#include "news.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

/* Allocate many vehicles */

   122

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

   123

{

   124

	int i;

   125

	Vehicle *v;

   126

	bool success = true;

   127

   128

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

   129

		vl[i] = v = AllocateVehicle();

   130

		if (v == NULL) {

   131

			success = false;

   132

			break;

   133

		}

   134

		v->type = 1;

   135

	}

   136

   137

	while (--i >= 0) {

   138

		vl[i]->type = 0;

   139

	}

   140

   141

	return success;

   142

}

   143

   144

int32 EstimateAircraftCost(EngineID engine_type)

   145

{

   146

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

   147

}

   148

   149

   150

/** Build an aircraft.

   151

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

   152

 * @param p1 aircraft type being built (engine)

   153

 * @param p2 unused

   154

 */

   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

	UnitID unit_num;

   160

	TileIndex tile = TileVirtXY(x, y);

   161

	const AircraftVehicleInfo *avi;

   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(tile) && IS_HUMAN_PLAYER(_current_player)) return CMD_ERROR;

   168

   169

	if (!IsTileOwner(tile, _current_player) && IS_HUMAN_PLAYER(_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) return value;

   176

   177

	avi = AircraftVehInfo(p1);

   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 = INVALID_STATION;

   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 = GetEngine(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

			const Station* st = GetStation(_m[tile].m2);

   265

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

   266

			uint i;

   267

   268

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

   269

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

   270

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

   271

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

   272

					break;

   273

				}

   274

			}

   275

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

   276

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

   277

		}

   278

   279

		v->u.air.state = HANGAR;

   280

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

   281

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

   282

		v->next = u;

   283

   284

		v->service_interval = _patches.servint_aircraft;

   285

   286

		v->date_of_last_service = _date;

   287

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

   288

   289

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

   290

   291

		VehiclePositionChanged(v);

   292

		VehiclePositionChanged(u);

   293

   294

		// Aircraft with 3 vehicles (chopper)?

   295

		if (v->subtype == 0) {

   296

			w = vl[2];

   297

   298

			u->next = w;

   299

   300

			w->type = VEH_Aircraft;

   301

			w->direction = 0;

   302

			w->owner = _current_player;

   303

			w->x_pos = v->x_pos;

   304

			w->y_pos = v->y_pos;

   305

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

   306

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

   307

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

   308

			w->z_height = 1;

   309

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   310

			w->subtype = 6;

   311

			w->cur_image = 0xF3D;

   312

			VehiclePositionChanged(w);

   313

		}

   314

   315

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   316

		RebuildVehicleLists();

   317

		InvalidateWindow(WC_COMPANY, v->owner);

   318

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

   319

	}

   320

   321

	return value;

   322

}

   323

   324

bool IsAircraftHangarTile(TileIndex tile)

   325

{

   326

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

   327

	// 0x20 - hangar large airport (32)

   328

	// 0x41 - hangar small airport (65)

   329

	return IsTileType(tile, MP_STATION) &&

   330

				(_m[tile].m5 == 32 || _m[tile].m5 == 65 || _m[tile].m5 == 86);

   331

}

   332

   333

static bool CheckStoppedInHangar(Vehicle *v)

   334

{

   335

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

   336

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   337

		return false;

   338

	}

   339

   340

	return true;

   341

}

   342

   343

   344

static void DoDeleteAircraft(Vehicle *v)

   345

{

   346

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   347

	RebuildVehicleLists();

   348

	InvalidateWindow(WC_COMPANY, v->owner);

   349

	DeleteVehicleChain(v);

   350

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   351

}

   352

   353

/** Sell an aircraft.

   354

 * @param x,y unused

   355

 * @param p1 vehicle ID to be sold

   356

 * @param p2 unused

   357

 */

   358

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

   359

{

   360

	Vehicle *v;

   361

   362

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   363

   364

	v = GetVehicle(p1);

   365

   366

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

   367

		return CMD_ERROR;

   368

   369

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   370

   371

	if (flags & DC_EXEC) {

   372

		// Invalidate depot

   373

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   374

		DoDeleteAircraft(v);

   375

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

   376

	}

   377

   378

	return -(int32)v->value;

   379

}

   380

   381

/** Start/Stop an aircraft.

   382

 * @param x,y unused

   383

 * @param p1 aircraft ID to start/stop

   384

 * @param p2 unused

   385

 */

   386

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

   387

{

   388

	Vehicle *v;

   389

   390

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   391

   392

	v = GetVehicle(p1);

   393

   394

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

   395

   396

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

   397

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

   398

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   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

/** Send an aircraft to the hangar.

   411

 * @param x,y unused

   412

 * @param p1 vehicle ID to send to the hangar

   413

 * @param p2 various bitmasked elements

   414

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

   415

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

   416

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

   417

 */

   418

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

   419

{

   420

	Vehicle *v;

   421

   422

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   423

   424

	v = GetVehicle(p1);

   425

   426

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

   427

   428

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

   429

		if (flags & DC_EXEC) {

   430

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

   431

			v->current_order.type = OT_DUMMY;

   432

			v->current_order.flags = 0;

   433

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

   434

		}

   435

	} else {

   436

		bool next_airport_has_hangar = true;

   437

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

   438

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

   439

		const Station *st = GetStation(next_airport_index);

   440

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

   441

		// it surely doesn't have any hangars

   442

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

   443

			StationID station;

   444

   445

			if (p2 != 0) return CMD_ERROR;

   446

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

   447

			station = FindNearestHangar(v);

   448

   449

			next_airport_has_hangar = false;

   450

			if (station == INVALID_STATION) return CMD_ERROR;

   451

			st = GetStation(station);

   452

			next_airport_index = station;

   453

   454

		}

   455

   456

		if (flags & DC_EXEC) {

   457

			v->current_order.type = OT_GOTO_DEPOT;

   458

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

   459

			v->current_order.station = next_airport_index;

   460

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

   461

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

   462

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

   463

				AircraftNextAirportPos_and_Order(v);

   464

				v->u.air.targetairport = next_airport_index;

   465

			}

   466

		}

   467

	}

   468

   469

	return 0;

   470

}

   471

   472

/** Change the service interval for aircraft.

   473

 * @param x,y unused

   474

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

   475

 * @param p2 new service interval

   476

 */

   477

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

   478

{

   479

	Vehicle *v;

   480

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

   481

   482

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

   483

   484

	v = GetVehicle(p1);

   485

   486

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

   487

   488

	if (flags & DC_EXEC) {

   489

		v->service_interval = serv_int;

   490

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

   491

	}

   492

   493

	return 0;

   494

}

   495

   496

/** Refits an aircraft to the specified cargo type.

   497

 * @param x,y unused

   498

 * @param p1 vehicle ID of the aircraft to refit

   499

 * @param p2 various bitstuffed elements

   500

 * - p2 = (bit 0-7) - the new cargo type to refit to (p2 & 0xFF)

   501

 * - p2 = (bit 8)   - skip check for stopped in hangar, used by autoreplace (p2 & 0x100)

   502

 * @todo p2 bit8 check <b>NEEDS TO GO</b>

   503

 */