1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "table/strings.h"

     8

#include "map.h"

     9

#include "tile.h"

    10

#include "vehicle.h"

    11

#include "depot.h"

    12

#include "engine.h"

    13

#include "command.h"

    14

#include "station.h"

    15

#include "news.h"

    16

#include "sound.h"

    17

#include "player.h"

    18

#include "airport.h"

    19

#include "vehicle_gui.h"

    20

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

static void CrashAirplane(Vehicle *v);

    28

    29

static void AircraftNextAirportPos_and_Order(Vehicle *v);

    30

static byte GetAircraftFlyingAltitude(const Vehicle *v);

    31

    32

static const SpriteID _aircraft_sprite[] = {

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

	0x0EBD, 0x0EC5

    40

};

    41

    42

/* Find the nearest hangar to v

    43

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

    44

 * airports (like helipads only)

    45

 */

    46

static StationID FindNearestHangar(const Vehicle *v)

    47

{

    48

	const Station *st;

    49

	uint best = 0;

    50

	StationID index = INVALID_STATION;

    51

    52

	FOR_ALL_STATIONS(st) {

    53

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

    54

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

    55

			uint distance;

    56

    57

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

    58

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

    59

					!_cheats.no_jetcrash.value)

    60

				continue;

    61

    62

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

    63

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

    64

				best = distance;

    65

				index = st->index;

    66

			}

    67

		}

    68

	}

    69

	return index;

    70

}

    71

    72

#if 0

    73

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

    74

static bool HaveHangarInOrderList(Vehicle *v)

    75

{

    76

	const Order *order;

    77

    78

	FOR_VEHICLE_ORDERS(v, order) {

    79

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

    80

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

    81

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

    82

			// it surely doesn't have any hangars

    83

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

    84

				return true;

    85

		}

    86

	}

    87

    88

	return false;

    89

}

    90

#endif

    91

    92

int GetAircraftImage(const Vehicle *v, byte direction)

    93

{

    94

	int spritenum = v->spritenum;

    95

    96

	if (is_custom_sprite(spritenum)) {

    97

		int sprite = GetCustomVehicleSprite(v, direction);

    98

    99

		if (sprite) return sprite;

   100

		spritenum = _engine_original_sprites[v->engine_type];

   101

	}

   102

	return direction + _aircraft_sprite[spritenum];

   103

}

   104

   105

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

   106

{

   107

	int spritenum = AircraftVehInfo(engine)->image_index;

   108

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

   109

   110

	if (is_custom_sprite(spritenum)) {

   111

		sprite = GetCustomVehicleIcon(engine, 6);

   112

		if (!sprite)

   113

			sprite = _engine_original_sprites[engine];

   114

	}

   115

   116

	DrawSprite(sprite | image_ormod, x, y);

   117

   118

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

   119

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

   120

	}

   121

}

   122

   123

/* Allocate many vehicles */

   124

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

   125

{

   126

	int i;

   127

	Vehicle *v;

   128

	bool success = true;

   129

   130

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

   131

		vl[i] = v = AllocateVehicle();

   132

		if (v == NULL) {

   133

			success = false;

   134

			break;

   135

		}

   136

		v->type = 1;

   137

	}

   138

   139

	while (--i >= 0) {

   140

		vl[i]->type = 0;

   141

	}

   142

   143

	return success;

   144

}

   145

   146

int32 EstimateAircraftCost(EngineID engine_type)

   147

{

   148

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

   149

}

   150

   151

   152

/** Build an aircraft.

   153

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

   154

 * @param p1 aircraft type being built (engine)

   155

 * @param p2 unused

   156

 */

   157

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

   158

{

   159

	int32 value;

   160

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

   161

	UnitID unit_num;

   162

	TileIndex tile = TileVirtXY(x, y);

   163

	const AircraftVehicleInfo *avi;

   164

	Engine *e;

   165

   166

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

   167

   168

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

   169

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

   170

   171

	if (!IsTileOwner(tile, _current_player) && IS_HUMAN_PLAYER(_current_player)) return CMD_ERROR;

   172

   173

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   174

   175

	value = EstimateAircraftCost(p1);

   176

   177

	if (flags & DC_QUERY_COST) return value;

   178

   179

	avi = AircraftVehInfo(p1);

   180

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

   181

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

   182

				IsOrderPoolFull())

   183

					return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   184

   185

	unit_num = GetFreeUnitNumber(VEH_Aircraft);

   186

	if (unit_num > _patches.max_aircraft)

   187

		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   188

   189

	if (flags & DC_EXEC) {

   190

		v = vl[0];

   191

		u = vl[1];

   192

   193

		v->unitnumber = unit_num;

   194

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

   195

		v->direction = 3;

   196

   197

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

   198

   199

		v->tile = tile;

   200

//		u->tile = 0;

   201

   202

		x = TileX(tile) * 16 + 5;

   203

		y = TileY(tile) * 16 + 3;

   204

   205

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

   206

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

   207

   208

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

   209

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

   210

   211

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

   212

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

   213

   214

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

   215

		v->z_height = 5;

   216

   217

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

   218

		u->z_height = 1;

   219

   220

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   221

		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER;

   222

   223

		v->spritenum = avi->image_index;

   224

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

   225

   226

		v->cargo_cap = avi->passenger_capacity;

   227

		u->cargo_cap = avi->mail_capacity;

   228

   229

		v->cargo_type = CT_PASSENGERS;

   230

		u->cargo_type = CT_MAIL;

   231

   232

		v->string_id = STR_SV_AIRCRAFT_NAME;

   233

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

   234

   235

//		v->load_unload_time_rem = 0;

   236

//		v->progress = 0;

   237

		v->last_station_visited = INVALID_STATION;

   238

//		v->destination_coords = 0;

   239

   240

		v->max_speed = avi->max_speed;

   241

		v->acceleration = avi->acceleration;

   242

		v->engine_type = (byte)p1;

   243

   244

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

   245

		v->value = value;

   246

   247

		u->subtype = 4;

   248

   249

		e = GetEngine(p1);

   250

		v->reliability = e->reliability;

   251

		v->reliability_spd_dec = e->reliability_spd_dec;

   252

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

   253

   254

		_new_aircraft_id = v->index;

   255

   256

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

   257

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

   258

		// On hold for NewAI

   259

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

   260

   261

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

   262

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

   263

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

   264

		*/

   265

		{

   266

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

   267

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

   268

			uint i;

   269

   270

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

   271

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

   272

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

   273

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

   274

					break;

   275

				}

   276

			}

   277

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

   278

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

   279

		}

   280

   281

		v->u.air.state = HANGAR;

   282

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

   283

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

   284

		v->next = u;

   285

   286

		v->service_interval = _patches.servint_aircraft;

   287

   288

		v->date_of_last_service = _date;

   289

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

   290

   291

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

   292

   293

		VehiclePositionChanged(v);

   294

		VehiclePositionChanged(u);

   295

   296

		// Aircraft with 3 vehicles (chopper)?

   297

		if (v->subtype == 0) {

   298

			w = vl[2];

   299

   300

			u->next = w;

   301

   302

			w->type = VEH_Aircraft;

   303

			w->direction = 0;

   304

			w->owner = _current_player;

   305

			w->x_pos = v->x_pos;

   306

			w->y_pos = v->y_pos;

   307

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

   308

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

   309

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

   310

			w->z_height = 1;

   311

			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;

   312

			w->subtype = 6;

   313

			w->cur_image = 0xF3D;

   314

			VehiclePositionChanged(w);

   315

		}

   316

   317

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   318

		RebuildVehicleLists();

   319

		InvalidateWindow(WC_COMPANY, v->owner);

   320

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

   321

	}

   322

   323

	return value;

   324

}

   325

   326

bool IsAircraftHangarTile(TileIndex tile)

   327

{

   328

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

   329

	// 0x20 - hangar large airport (32)

   330

	// 0x41 - hangar small airport (65)

   331

	return IsTileType(tile, MP_STATION) &&

   332

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

   333

}

   334

   335

bool CheckStoppedInHangar(Vehicle *v)

   336

{

   337

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

   338

		_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED;

   339

		return false;

   340

	}

   341

   342

	return true;

   343

}

   344

   345

   346

static void DoDeleteAircraft(Vehicle *v)

   347

{

   348

	DeleteWindowById(WC_VEHICLE_VIEW, v->index);

   349

	RebuildVehicleLists();

   350

	InvalidateWindow(WC_COMPANY, v->owner);

   351

	DeleteVehicleChain(v);

   352

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   353

}

   354

   355

/** Sell an aircraft.

   356

 * @param x,y unused

   357

 * @param p1 vehicle ID to be sold

   358

 * @param p2 unused

   359

 */

   360

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

   361

{

   362

	Vehicle *v;

   363

   364

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   365

   366

	v = GetVehicle(p1);

   367

   368

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

   369

		return CMD_ERROR;

   370

   371

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   372

   373

	if (flags & DC_EXEC) {

   374

		// Invalidate depot

   375

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   376

		DoDeleteAircraft(v);

   377

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

   378

	}

   379

   380

	return -(int32)v->value;

   381

}

   382

   383

/** Start/Stop an aircraft.

   384

 * @param x,y unused

   385

 * @param p1 aircraft ID to start/stop

   386

 * @param p2 unused

   387

 */

   388

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

   389

{

   390

	Vehicle *v;

   391

   392

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   393

   394

	v = GetVehicle(p1);

   395

   396

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

   397

   398

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

   399

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

   400

		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);

   401

   402

	if (flags & DC_EXEC) {

   403

		v->vehstatus ^= VS_STOPPED;

   404

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

   405

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   406

		InvalidateWindowClasses(WC_AIRCRAFT_LIST);

   407

	}

   408

   409

	return 0;

   410

}

   411

   412

/** Send an aircraft to the hangar.

   413

 * @param x,y unused

   414

 * @param p1 vehicle ID to send to the hangar

   415

 * @param p2 various bitmasked elements

   416

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

   417

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

   418

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

   419

 */

   420

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

   421

{

   422

	Vehicle *v;

   423

   424

	if (!IsVehicleIndex(p1)) return CMD_ERROR;

   425

   426

	v = GetVehicle(p1);

   427

   428

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

   429

   430

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

   431

		if (flags & DC_EXEC) {

   432

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

   433

			v->current_order.type = OT_DUMMY;

   434

			v->current_order.flags = 0;

   435

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

   436

		}

   437

	} else {

   438

		bool next_airport_has_hangar = true;

   439

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

   440

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

   441

		const Station *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 (!IsValidStation(st) || st->airport_tile == 0 || GetAirport(st->airport_type)->nof_depots == 0) {

   445

			StationID station;

   446

   447

			if (p2 != 0) return CMD_ERROR;

   448

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

   449

			station = FindNearestHangar(v);

   450

   451

			next_airport_has_hangar = false;

   452

			if (station == INVALID_STATION) return CMD_ERROR;

   453

			st = GetStation(station);

   454

			next_airport_index = station;

   455

   456

		}

   457

   458

		if (flags & DC_EXEC) {

   459

			v->current_order.type = OT_GOTO_DEPOT;

   460

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

   461

			v->current_order.station = next_airport_index;

   462

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

   463

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

   464

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

   465

				AircraftNextAirportPos_and_Order(v);

   466

				v->u.air.targetairport = next_airport_index;

   467

			}

   468

		}

   469

	}

   470

   471

	return 0;

   472

}

   473

   474

/** Change the service interval for aircraft.

   475

 * @param x,y unused

   476

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

   477

 * @param p2 new service interval

   478

 */

   479

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

   480

{

   481

	Vehicle *v;

   482

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

   483

   484

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

   485

   486

	v = GetVehicle(p1);

   487

   488

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

   489

   490

	if (flags & DC_EXEC) {

   491

		v->service_interval = serv_int;

   492

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

   493

	}

   494

   495

	return 0;

   496

}

   497

   498

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

   499

 * @param x,y unused

   500

 * @param p1 vehicle ID of the aircraft to refit

   501

 * @param p2 various bitstuffed elements

   502

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

   503

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